Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Otro uso para la arroba (@) en C#
José María Aguilar - Cómo hacer que Fiddler inicie sin capturar conexiones
José María Aguilar
.NET Core / .NET
- .NET type for personally identifiable information (PII)
Vladimir Gaevoy - Performance benefits of sealed class in .NET
Gérald Barré - Building a NuGet Packages Architecture Part 5 – Service Registration Methods
Imar Spaanjaars - How to prevent email HTML injection in C# and .NET
Niels Swimberghe - Creating a Windows Service with .NET 6
Christian Nagel - Just because you stopped waiting for it, doesn't mean the Task stopped running
Andrew Lock - Unit Tests For Legacy Systems with .NET 6
Khalid Abuhakmeh - Get ready for NativeAOT in .NET 7
Maourice Gonzalez - Building NServiceBus Metrics with OpenTelemetry and System.Diagnostics.Metrics
Jimmy Bogard - Remove Time from a DateTime Object in C#
Code Maze - How to use pub/sub in C# .NET to build a chat app
Marc Duiker - How segments and regions differ in decommitting memory in the .NET 7 GC
Maoni Stephens
Aunque no es algo frecuente ni especialmente recomendable, hay veces que tenemos que introducir en el código algún tipo de lógica, trazas o comprobaciones que solo queremos aplicar mientras depuramos o desarrollamos y, en ningún caso, queremos que vaya a producción.
En estos casos, aparte de anudarnos un lazo en el dedo mientras mantengamos estos cambios para asegurar la eliminación del código de pruebas antes de subir la aplicación a producción, otra idea puede ser utilizar directivas para que este código solo actúe mientras depuramos, o incluso para evitar la compilación exitosa en modo "Release" (el usado normalmente al publicar).
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Enumerables asíncronos en C# 8
José María Aguilar - Problemas al comentar el código fuente
José María Aguilar
.NET Core / .NET
- 5 mitos de .NET que todavía te crees (20 años después)
José Manuel Alarcón - Announcing .NET 7 Preview 2 - The New, 'New' Experience
Angelos Petropoulos - Why should you use a random testing library in C#?
Anthony Lloyd - UsedImplicitly on External Libraries
Phil Scott - Writing IL according to the specification
Dudi Keleti - A deep-dive into the new Task.WaitAsync() API in .NET 6
Andrew Lock - What’s New in C# 10: Create Constants Using String Interpolation
Jason Roberts - Finding the brightest area in an image with C# (fixing a blurry presentation video
Dan Roberts - Cancellation, Part 4: Polling
Stephen Cleary - Advanced parsing using Int.TryParse in C#
Davide Bellone - Polly with .NET 6, Part 4 - Dependency Injection of a HttpClientFactory and Policy into a Minimal API Endpoint
Bryan Hogan - A Mostly Complete Guide to C# 11’s Future Features
Matthew MacDonald - How to Deserialize a Complex JSON Object in C# .NET
Code Maze - How to use Google.Protobuf without code generation in C#
Mike Hadlow
En los tiempos de ASP.NET "clásico", cuando los settings de la aplicación los almacenábamos en el viejo Web.config, cualquier intento de cambio de valores mientras ejecutábamos la aplicación era inevitablemente sinónimo de reinicio. Esto, aunque bastante molesto, tenía sentido porque el mismo archivo XML se utilizaba para almacenar tanto los valores de configuración "de negocio" como aspectos puramente técnicos o del comportamiento de la infraestructura de ASP.NET, y la aplicación debía reiniciarse para poder aplicarlos.
Con la llegada del sistema de settings de .NET Core esto mejoró bastante, introduciendo la posibilidad de almacenar valores en bastantes orígenes distintos (archivos .json, .ini, .xml, variables de entorno, parámetros de línea de comandos, user secrets, diccionarios en memoria y muchos otros, incluso totalmente personalizados), y nuevas fórmulas para la obtención de éstos, como la inyección de dependencias, settings tipados y, por fin, la posibilidad de realizar cambios en caliente.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Saber si una cadena está vacía en C#
José María Aguilar - Switch expressions en C# 8
José María Aguilar
.NET Core / .NET
- Implementing a defaultable collection in C#
Steve Dunn - Building a gRPC Server in .NET
Sahan Serasinghe - QR Code Encoder and Decoder C# Class Library for VS 2022 .NET 6.0 (Version 3.0.0)
Uzi Granot - Polly with .NET 6, Part 3 - Dependency Injection of a Policy into a Minimal API Endpoint
Bryan Hogan - Executing code before Main in .NET
Gérald Barré - Cancelling await calls in .NET 6 with Task.WaitAsync()
Andrew Lock - Loop Around Index with C# Collections
Khalid Abuhakmeh - What’s the maximum number of arguments for method in C# and in .NET?
Jiří Činčura - Downloading and Pushing NuGet packages in C#
Mark Heath - .NET 4.x app running in a container using Docker
Gregor Suttie - Cancellation, Part 3: Detecting Cancellation
Stephen Cleary - Typemock Isolator dotnet core support
Alon Sapozhnikov
No podemos negar que el tipo de datos boolean está fuertemente arraigado en los desarrolladores. Desde nuestros inicios en este mundillo, nos acostumbramos a pensar que las máquinas sólo entienden de unos y ceros o sus variantes humanas: "sí" y "no", "verdadero" y "falso" o similares. Y por alguna misteriosa razón, tendemos a ver la realidad y modelar nuestras soluciones utilizando estas primitivas tan básicas.
Pero aunque indudablemente los tipos booleanos o flags son una fórmula muy compacta para almacenar información, el mundo suele ser mucho más complejo y estas simplificaciones son a menudo origen de problemas y trampas para nuestro yo del futuro.
En este post vamos a ver algunos escenarios en los que este tipo de dato puede llegar a complicarnos la vida.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Implementación por defecto en interfaces de C#8, un primer vistazo
José María Aguilar - Enumeraciones de campos de bits en .NET
José María Aguilar
.NET Core / .NET
- Mapperly: A .NET source generator for generating object mappings Riok
- Reentrant (Recursive) Async Lock is Impossible in C#
Max Fedotov - Differences Between != And Is Not Operators in C#
Code Maze - Global usings in C# 10
Gunnar Peipman - Build your own simple browser with WebView2
Mark Heath - Modelling workflows with Finite State Machines in .NET
Lloyd Atkinson - Profiling a .NET6 app running in a linux container with dotnet-trace, dotnet-dump, dotnet-counters, dotnet-gcdump and Visual Studio
Carlos Pons - Enabling High-Quality Code in .NET
Milan Milanović - PriorityQueue In .NET 6
Vicente Gerardo Guzman Lucio - Difference Between Task.Run and Task.Factory.StartNew
Code Maze - 13 C# NuGet packages every .NET Developer needs to know!
Claudio Bernasconi - LED Ticker Tape with .NET
Jim Bennett - Cancellation, Part 2: Requesting Cancellation
Stephen Cleary - Understanding the .NET Language Integrated Query (LINQ)
Ioannis Kyriakidis - Classes, Structures, and Records, Oh My!
David McCarter
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Tipos referencia anulables en C# 8
José María Aguilar - Concatenando un string multilínea en C#
José María Aguilar
.NET Core / .NET
- Introducing C# 10: Structs parameterless constructor and instance field initializer
Anthony Giretti - Improve C# code performance with Span<T>
Patrick Smacchia - The pain points of C# source generators: February 2022 Update
James Turner - Early peek at C# 11 features
Kathleen Dollard - Requiring two-factor authentication on NuGet.org
Claire Novotny - Please stop lying about .NET Standard 2.0 support!
Andrew Lock - Devs Sound Off on C# 11 Preview Features Like Parameter Null Checking
David Ramel - Using RestSharp To Consume APIs in C#
Marinko Spasojevic - Cancellation, Part 1: Overview
Stephen Cleary - Recommended container limits for dotnet-monitor
Mark Downie - Convert Country Name To Flag Emoji in C# & the .NET ecosystem
The First Prototype - Getting Started With .NET 7.0
Satya Karki - How to Upload a File to Azure Blob Storage
Claudio Bernasconi - Alias: An approach to .NET Assembly Conflict Resolution
Bruno Garcia & Simon Cropp
Aún no hemos terminado de asimilar las novedades de C# 10, cuando ya empiezan a llegar noticias de lo que encontraremos en la próxima versión, C# 11, que si todo va bien se lanzará en noviembre de este año.
Una de las que más me ha llamado la atención de momento es la llegada de raw string literals, una característica que mejorará bastante la posibilidad de escribir constantes de cadena multilínea en nuestro código.
Veamos en qué consiste.
Disclaimer: la nueva versión de C# está aún en desarrollo, y detalles de los que veamos aquí podrían cambiar antes de lanzarse definitivamente.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Null coalescing assigment "??=", el nuevo operador de asignación en C# 8
José María Aguilar - Constantes string multilínea en C#
José María Aguilar
.NET Core / .NET
- Lenguaje C#: coincidencia de modelos - Parte 2: Uso de expresiones en el switch
Rubén Rubio - Announcing .NET 7 Preview 1
Jeremy Likness - .NET and C# Versions - 20th Anniversary
Niels Rasmussen - My 20 Years with .NET
Mark Rendle - Announcing ImageSharp 2.0.0
Six Labors - C# Nullable Features thru the times
Christian Nagel - AutoMapper, Nullable DateTime, and Selecting the Right Constructor
Travis Illig - Operator Overloading in C#
Marinko Spasojevic - Logging Trace Output Using ILogger in .NET Applications
Khalid Abuhakmeh - Introducing Compatible Packages on NuGet.org
Jon Douglas - Server-side JavaScript for .NET developers – Part I (Node.js fundamentals)
Daniel Jiménez García - C# 11.0 preview: parameter null checking
Ian Griffiths - 7 Improvements You Might Have Missed in .NET 6
Matthew MacDonald - C#11 Parameter Null Checking
Wade Gausden - Use a .NET Worker Service to run background services
David Grace
Seguimos descubriendo novedades aparecidas con .NET 6, y ahora le toca el turno a la nueva clase PeriodicTimer, una fórmula para la ejecución de tareas periódicas en contextos asíncronos que evita el uso de los clásicos callbacks a los que nos tenía acostumbrados el framework.
Como recordaréis, .NET dispone de un buen número de formas de implementar temporizadores, o timers, para ejecutar tareas en intervalos periódicos. El más conocido probablemente sea el clásico System.Threading.Timer, en el que especificábamos el callback o método que debía ejecutarse en cada intervalo de tiempo mediante un delegado (en el siguiente ejemplo, mediante una lambda):
var timer = new System.Threading.Timer(o =>
{
Console.WriteLine("Hey! " + DateTime.Now.ToLongTimeString());
}, null, 0, 1000);
Console.ReadKey();
Hey! 12:25:51
Hey! 12:25:52
Hey! 12:25:53
Hey! 12:25:54
Hey! 12:25:55
_
Pero también existía System.Timers.Timer, que nos permitía lograr algo parecido, aunque esta el callback lo implementábamos mediante una suscripción al evento Elapsed del objeto:
var timer = new System.Timers.Timer(1000);
timer.Elapsed += (sender, eventArgs) =>
{
Console.WriteLine("Hey! " + DateTime.Now.ToLongTimeString());
};
timer.Start();
Console.ReadKey();
Existían algunas fórmulas más específicas para plataformas concretas, como las clases System.Windows.Forms.Timer, System.Web.UI.Timer u otras. Sin embargo, todas coincidían en varias cosas:
- Utilizaban callbacks de alguna u otra forma, lo que implica un cierto riesgo de leaks de memoria y problemas con los tiempos de vida de objetos cuando la cosa se complica.
- Los callbacks no permitían código asíncrono, lo que podía llevarnos a luchar contra los engorrosos escenarios de ejecución de código asíncrono en entornos síncronos (async-over-sync).
- Podían darse casos de superposición u overlapping entre las distintas ejecuciones, cuando éstas tardaban en completarse más que el intervalo de definido en el timer.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- 10 razones por las que tu blog te ayuda a encontrar empleo
José María Aguilar - Etiquetado de consultas en Entity Framework 6
José María Aguilar
.NET Core / .NET
- Lenguaje C#: Coincidencia de modelos - Parte 1: Fundamentos
Rubén Rubio - Happy 20th Anniversary, .NET!
Beth Massi - Debug attributes in .NET
Steve Dunn - Unit Tests for Expected Exceptions
Jeremy D. Miller - Creating and Using HTTP Client SDKs in .NET 6 Oleksii Nikiforov
- Avoid DNS issues with HttpClient in .NET
Gérald Barré - Using OpenAPI Generator To Scaffold APIs And API Clients
Wade Gausden - NetEscapades.EnumGenerators: a source generator for enum performance
Andrew Lock - Async streams in C# – Deep Dive
Damir Arh - What is the cost of casting in .NET (C#)?
Jiří Činčura - Migrate from .NET Framework to .NET Core (.NET 6)
Sanjay M. - Download, parse, and store SSL certificates in C#
Thomas Ardal - Improvements and Optimizations for Interpolated Strings – A Look at New Language Features in C# 10
Alexandra Kolesova - C# Tip: Exception handling with WHEN clause
Davide Bellone - Measuring Performance After Migration from .NET5 to .NET 6
Dmitry Kulagin - C# 10.0 improves handling of nullable references in generic types
Ian Griffiths - Diagnosing and Fixing MediatR Container Issues
Jimmy Bogard - Using Azure Active Directory B2C with .NET
Christian Nagel - Attribute on attribute itself
Jiří Činčura - Introducing FakeAuth for .NET Core
Caleb Jenkins - ThunderboltIoc: .NET Dependency Injection without Reflection!
Aly Elhaddad
Dada una petición como la siguiente:
POST https://localhost:5001/friends HTTP/1.1
Host: localhost:5001
Content-Type: application/json
{ "name": "Jon", "age": 24 }
Lo habitual es que queramos recibir los datos ya materializados en forma de objeto de .NET. Esto podemos conseguirlo fácilmente desde una acción como la siguiente:
[Route("friends")]
public class FriendsController : Controller
{
[HttpPost]
public ActionResult Test([FromBody]Friend friend)
{
return Content($"Hello, {friend.Name}, you are {friend.Age} years old");
}
}
Pero aunque no es algo que ocurra con frecuencia, a veces podríamos necesitar recibir el cuerpo JSON de una petición como string, es decir, en crudo, sin deserializarlo ni procesarlo de ninguna manera para, ya más adelante, hacerlo nosotros manualmente. Y aunque a primera vista pudiera resultar trivial, tiene un poco más de truco de lo que parece...
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Cómo saber si un tipo está registrado en el proveedor de servicios de .NET 6, pero sin necesidad de resolverlo
José María Aguilar - Etiquetado de consultas en Entity Framework Core
José María Aguilar
.NET Core / .NET
- De runas y grafemas en Unicode y NET6
Eduard Tomás - Celebrate the .NET 20th Anniversary with the Community!
James Montemagno - Dynamic Language Runtime in C#/.NET
Uladzislau Baryshchyk - Using Generated Methods Instead of Reflection
Ricardo Peres - A type-safe DI Container C# example
Mark Seemann - .NET Framework vs .NET Core (.NET 5+)
Sanjay M. - Parallelize test cases execution in xUnit
Gérald Barré - Linq improvements in .NET 6
Bruno Sonnino - Databinding with the OOP Windows Forms Designer
Klaus Loeffelmann - Solving the source generator 'marker attribute' problem - Part 2: Creating a source generator
Andrew Lock - Static Abstract Members In C# 10 Interfaces
Khalid Abuhakmeh - How to Create PDF file in C# .NET – 5 Easy Steps
Sanjay M. - Hello OmniSharp on .NET 6.0!
Filip Woj - World’s smallest C# program (featuring cheating)
Jiří Činčura - Improve Code Quality with BannedSymbolAnalyzers
Max Hamulyák - Automate your .NET project builds with NUKE a cross-platform build automation solution
Laurent Kempé - Pure magic in C# using tuples and relational patterns
Jiří Činčura - 3 Ways To Increase App Reliability With Polly
Stuart Blackler - .NET Basics: DTO (Data Transfer Object)
Assis Zang - This is how Variadic Arguments could work in C#
WhiteBlackGoose - What’s up with TimeZoneInfo on .NET 6? (Part 1)
Jon Skeet
Si habéis utilizado isolation con módulos JavaScript en Blazor 5, probablemente lo que vamos a ver en este post os resulte muy interesante para organizar los archivos JavaScript de la aplicación, especialmente aquellos que sean utilizados desde un único componente.
Como recordaréis, el aislamiento de JavaScript de Blazor permitía cargar de forma dinámica un archivo .js y ejecutar código definido en él. Por ejemplo, imaginad un módulo como el siguiente, definido en wwwroot/modules/MyPrompt.js:
export function showPrompt(message, defaultValue) {
return prompt(message, defaultValue);
}
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Declaración de espacios de nombre en una línea con file-scoped namespaces de C#10
José María Aguilar - Índices y rangos en C# 8 (2 de 2)
José María Aguilar
.NET Core / .NET
- Announcing .NET Community Toolkit v8.0.0 Preview 1
Sergio Pedri - C# 10 (Two Decades of C#: A Reference) • Ben Bowen's Blog
Ben Bowen - Dependency Injection in .NET 6
Matthew Jones - Awaiting an async void method in .NET
Gérald Barré - Simple WebSocket client and server application using .NET
Jiří Činčura - Top-Level Statements in C#
Marinko Spasojevic - Bulk download from Azure Blob Storage with C#
Thomas Ardal - Using Guard Clauses in .NET
Charlin Agramonte - Solving the source generator 'marker attribute' problem - Part 1: Creating a source generator
Andrew Lock - Colors in .NET: An In-Depth Guide
Peter Huber - Difference Between int.Parse() and Convert.ToInt32() in C#
Marinko Spasojevic - Raising Coding Standards with .NET 6.0 Code Analyzers
Ian Griffiths - Switch Expression with Multiple Cases That Return the Same Result in C#
Marinko Spasojevic - Using OAuth 2.0 with LINQ to Twitter
Joe Mayo - Everything You Want to Know About the Record Type in .NET: Performance
David McCarter - De-mystifying Linq
Steve Fenton - How to collect return values from Parallel.ForEach?
Patrick Smacchia - How to Create a PNG File from a Web Page in C#
Roland Weigelt - Validating Objects With FluentValidation
Assis Zang - 6 .NET Myths Dispelled-Celebrating 21 Years of .NET
Charles Chen - How to Use Serilog in ASP.NET Core Web API
Claudio Bernasconi - .NET 6 Register Services using Reflection
Tom Fletcher
El middleware de gestión de errores DeveloperExceptionPageMiddleware ha estado con nosotros desde la llegada de .NET Core, allá por 2016, ayudándonos a mostrar información detallada de las excepciones producidas en tiempo de ejecución mientras estábamos desarrollando. De hecho, era frecuente encontrar un código como el siguiente en las clases Startup de las aplicaciones ASP.NET Core, pues se incluía por defecto en todas las plantillas de proyecto de este tipo:
...
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
... // Otros middlewares
}
El extensor UseDeveloperExceptionPage() era el encargado de añadir el middleware DeveloperExceptionPageMiddleware al pipeline, de forma que éste podía capturar las excepciones y mostrar una página amigable y con información útil para los desarrolladores.
Sin embargo, si echamos un vistazo al código de configuración del pipeline en los proyectos ASP.NET Core 6 (que, por cierto, sabréis que ya no se encuentra en Startup.cs sino en Program.cs), vemos que ya no aparece ninguna referencia a este middleware. ¿Qué ha pasado? ¿Qué has hecho con nuestro DeveloperExceptionPage, ASP.NET Core 6?
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Curiosidad: ¿Por qué el encabezado 'referer' se llama así, y cómo nos afecta a los desarrolladores .NET?
José María Aguilar - Índices y rangos en C# 8 (1 de 2)
José María Aguilar
.NET Core / .NET
- Saving source generator output in source control: Creating a source generator
Andrew Lock - Get C# Metadata From a Call Site
Khalid Abuhakmeh - C# and C++ type aliases and their consequences
Raymond Chen - ILogger, ILoggerFactory, and ILoggerProvider in .NET
Marinko Spasojevic - Dependency Injection in .NET 6 - Adding and Injecting Dependencies
Matthew Jones - Serializing Objects to XML in C#
Marinko Spasojevic - 5 Features in C# 10 Every Developer Should Know
Selva Kumar Ramarasu - Bending .NET - Corrected Common Flat Build Output
Niels Rasmussen - Wait conditions in Selenium with C#
James Croft - Why Use DateTimeOffset
Steve Smith - Protobuf In C# .NET – Part 4 – Performance Comparisons
Wade Gausden - Optimizing CPU-Bound and Memory-Bound .NET Applications: 11 Best Practices
Michael Shpilt - Convert DateTime to ISO 8601 String in C#
Marinko Spasojevic - How to send recurring emails in C# .NET using SendGrid and Quartz.NET
Niels Swimberghe - Bending DateTime in .NET to Test Your Code Better
Stephen Walsh - New Task.WaitAsync method in .NET 6
Jiří Činčura
Versiones de .NET anteriores a la 6 no disponían de una fórmula específica para determinar si un tipo o interfaz está registrado como servicio en el sistema de inyección de dependencias.
La única forma de hacerlo era intentar resolverlo, usando métodos como GetService() o GetService<T>(), y comprobar si el resultado era null:
var myService = serviceProvider.GetService<IMyService>();
if(myService is null)
{
// El servicio no está registrado, hacemos algo
}
¿Cuál es el inconveniente de esto? Si el servicio no está registrado, ninguno: la llamada retornará un nulo y listo.
El problema viene cuando sí está registrado, pues estaremos forzando la resolución de un servicio que, en realidad, no necesitamos para nada, pues sólo nos interesaba saber si existía o no. Porque recordemos que la resolución de un servicio podría tener un coste importante en términos de rendimiento, memoria, o incluso efectos colaterales en el estado de la aplicación, especialmente si nuestro servicio depende de otros, que a su vez dependen de otros, etc.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- El atributo CallerArgumentExpression, o cómo conocer las expresiones usadas como argumentos en llamadas a un método en C#
José María Aguilar - Value Converters en Entity Framework Core
José María Aguilar
.NET Core / .NET
- ¿Qué son los deconstructores en C# y para qué sirven?
Rubén Rubio - Things you might not know about CSharp - Duck typing
Stuart Blackler - Dependency Injection in .NET 6
Matthew Jones - C# StringBuilder and String vs StringBuilder in C# .NET
Sanjay M. - Finding a type declaration's namespace and type hierarchy: Creating a source generator
Andrew Lock - Tips for More Efficient .NET Logs
Assis Zang - Why non-defaultable value types are needed in C#
Steve Dunn - Tuple in C#
Marinko Spasojevic - Flow control in C#
Jessica Hill - DateTime as a Value Object
Steve Smith - State of the Windows Forms Designer for .NET Applications
Klaus Loeffelmann - Protobuf In C# .NET - Part 1 - Getting Started
Wade Gausden
Vamos con la primera colección del año :) Aquí van los enlaces recopilados durante estas fiestas que, como de costumbre, espero que os resulten interesantes.
Por si te lo perdiste...
- Cómo evitar que entren argumentos nulos en métodos de C#: un recorrido histórico (y lo que nos trae el futuro)
José María Aguilar - Ámbito local implícito en sentencias using de C# 8
José María Aguilar
.NET Core / .NET
- Pasar argumentos en la aplicación de consola con Net 6 y Visual Studio 2022
Daniel Córdoba - Thirteen C# 10 features
Oleg Kyrylchuk - When to Use Static Classes in C#
Marinko Spasojevic - Difference Between Asynchronous Programming and Multithreading
Marinko Spasojevic - Creating .NET Project Templates
James McCaffrey - How to Detect if a Dictionary Key Exists in C#
Marinko Spasojevic - Things you might not know about CSharp - Using Params with Indexers
Stuart Blackler - Accurately Measure Elapsed Time (Execution Time) in C# .NET using Stopwatch Class
Pro Code - Chi-Square Test Using C#
- Upgrading from .NET Core 2.1 to .NET 6.0
Jason Sultana - Create your own Roslyn Analyzer
Ahd BK - How to stop forgetting to await an awaitable call
Dennis Doomen - .NET's Cryptographic One-Shots
Kevin Jones - C# Binary Search: Fast find of a free slot between 0 and uint.MaxValue
Patrick Smacchia - Customising generated code with marker attributes: Creating a source generator
Andrew Lock - Create Context-based Programming Models with .NET 6
Khalid Abuhakmeh - 10 Best C# NuGet Packages to Improve Your Productivity in 2022
Sangeetha Periyaiah - Deep C# - Inheritance
Mike James - System.Text.Json features in .NET 6
Oleg Kyrylchuk - Mini C# Extension Methods
Matthew Jones - Integrating Long Path Names in Windows Applications
Rick Strahl
Pues parece que comenzamos 2022 con deseos bastante parecidos a los que ya teníamos un año atrás: que la situación actual mejore y que la salud os permita ser felices y disfrutar de todo lo que os rodea. Algo hemos avanzado respecto al año pasado, pero aún nos queda mucho camino por recorrer para volver a la ansiada normalidad.
Pero bueno, independientemente de esto, seguro que lo que más estáis esperando en este momento es el tradicional post donde comentaremos las entradas más visitadas durante el pasado año, así que ahí va 😁
Hace ya mucho tiempo que C# inició un interesante camino para conseguir reducir la cantidad de código necesario para hacer cosas frecuentes, introduciendo la capacidad de hacer implícitas determinadas construcciones y, por tanto, ahorrándonos tiempo y pulsaciones de teclas innecesarias.
En esta línea, todos recordaréis el tipado implícito, que tanto debate abrió en el lanzamiento de C# 3, hace ya casi quince años:
// Antes de C# 3
List<string> strings = new List<string>();
// Usando tipado implícito
var strings = new List<string>();
Bastante tiempo después, ya con C# 10, el lenguaje nos regaló una nueva característica que iba en la misma dirección, las expresiones new con el tipo destino. Éstas permitían construir objetos usando tipado implícito, aunque esta vez en el lado derecho de las expresiones:
// Antes de C# 10
public class MyClass
{
private Invoice invoice = new Invoice(123);
private Dictionary<string, Person> people = new Dictionary<string, Person>();
...
}
// Ahora
public class MyClass
{
private Invoice invoice = new (123);
private Dictionary<string, Person> people = new ();
...
}
También en C# 10 nos hemos encontrado con los using globales y using implícitos, características ambas que nos permiten economizar esfuerzos evitando la introducción repetitiva de directivas para la importación de namespaces en el código.
Pues bien, aquí viene la siguiente vuelta de tuerca :) Unas semanas atrás, Immo Landwerth (Program manager de .NET en Microsoft) sorprendía a todos con esta afirmación sobre una de las características principales del próximo C# 11:
Ante todo, espero que estés pasando unas muy felices fiestas y con buena salud, a pesar de las circunstancias complicadas que nos rodean. Espero que pronto podamos salir de todo esto y volver a la normalidad.
Y mientras tanto, os paso algunos enlaces recopilados durante la semana pasada, que espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Generación de rutas con parámetros de query string en Blazor 6
José María Aguilar - Constructores con parámetros en entidades EF Core
José María Aguilar
.NET Core / .NET
- Microsoft .NET History
Lazie Wouters - Ensuring Santa’s Success With Automated Tests (C# Advent 2021)
Sean Killeen - Reentrant (Recursive) Async Lock is Impossible in C#
Max Fedotov - Third-Party DI Container And Autofac
Marinko Spasojevic - Getting Roslyn (C# compiler) and Language versions
Gérald Barré - AutoMapper runtime mapping control via IMappingOperationOptions
Adam Flow - Cancelling IAsyncEnumerable in C#
Jeremy Clark - How to compare two files using .NET, really really fast!
Sungu, Hasan Emrah - Why C# goes well with TypeScript
Nate Hill - How to Convert Char Array to String in C#
Marinko Spasojevic - Integration testing and NuGet packaging: Creating a source generator
Andrew Lock - Refactoring with C# 10
Jonathan Danylko - Using DateOnly and TimeOnly in .NET 6 to Simplify Your Code
Christopher C. Johnson - gRPC client-side load balancing in .NET
Rebin Qadir - How to Generate Random Numbers From a Range in C#
Marinko Spasojevic - 5 Easy Ways to Protect Excel Data in C#
Mohan Chandran - As and Is Operators in C#
Marinko Spasojevic
Parece que uno de los objetivos de C#10 es eliminar código de los archivos de código fuente de C#, simplificando su codificación y lectura. Lo hemos visto con la introducción de características como directivas using globales o los using implícitos: en ambos casos se ahorraba espacio en vertical sustituyendo los using declarados individualmente en cada archivo por directivas aplicadas de forma global al proyecto, bien de forma explícita o implícita.
En cambio, los espacios de nombre con ámbito de archivo o namespace declarations permiten ahorrar espacio en horizontal, evitando un nivel de indentación en el código que la mayoría de las veces es innecesario.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- ¿Por qué no compila este código C#?
José María Aguilar - Backing fields en Entity Framework Core
José María Aguilar
.NET Core / .NET
- C# 10: "usings" globales e implícitos
José Manuel Alarcón - .NET 6 Networking Improvements
Máňa Píchová - How to Upgrade a Codebase from .NET Framework to .NET 6
Christian Findlay - Parallel.ForEachAsync Deep Dive
Greg Bair - .NET 6 vs .NET 4.8 GC stats - ~64% shorter max GC pause times (due to 1 letter removed in runtime)
Niels Rasmussen - How to Run Code in a New Thread in C#
Marinko Spasojevic - Testing an incremental generator with snapshot testing: Creating a source generator
Andrew Lock - Remove those useless File.Exists calls
Gérald Barré - How to Check if a StringBuilder Is Empty
Marinko Spasojevic - C# Tip: use yield return to return one item at the time
Davide Bellone - Send Emails using the SendGrid API with .NET 6 and C#
Niels Swimberghe - Getting Started With .NET IL
Mike James - How to Get an Item by Index From Dictionary in C#
Marinko Spasojevic - 7 Ways to Find and Highlight Text in a PDF Using .NET C#
Mackenzie Albitz - Collection Performance: How Do You LINQ?
David McCarter - Send Emails using the SendGrid API with .NET 6 and C#
Niels Swimberghe - String Interpolation Trickery and Magic with C# 10 and .NET 6
Brant Burnett - Unit Testing ILogger
Jonathan Danylko - Syncfusion Essential Studio 2021 Volume 4 Is Here!
Suresh M.
Como sabemos, en las peticiones HTTP se envían al servidor un conjunto de “parámetros” o encabezados que añaden información extra para que la solicitud pueda ser procesada correctamente. Ahí encontramos información sobre el lado cliente, como la cadena de agente de usuario (encabezado user-agent), información sobre la propia petición, como el host al que se dirige la petición (encabezado host) o los idiomas que se aceptan para el contenido (accept-language), e incluso información contextual como las cookies del usuario (cookie) o información de autorización (authorization), entre muchos otros.Hoy vamos a detenernos en una curiosidad histórica sobre el protocolo HTTP y uno de sus más célebres encabezados :)
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Crear proyectos usando versiones específicas del SDK de .NET Core
José María Aguilar - Implicit usings en C#10
José María Aguilar
.NET Core / .NET
- What's new for gRPC in .NET 6
James Newton-King - An optimization story:–27% runtime costs for 8 lines of code
Oren Eini - Fastest way to enumerate a List<T>
Gérald Barré - What’s New in C# 10: Simplify Nested Property Pattern Code
Jason Roberts - Cancellation Tokens with IAsyncEnumerable
Marinko Spasojevic - Profiling .NET code with MiniProfiler
Davide Bellone - Could .NET Source Generator Attacks Be A Danger To Your Code?
Steve Collins - Don't Do That, Do This: The .NET 6 Edition
Dave Brock - Creating an incremental generator: Creating a source generator
Andrew Lock - Traversing the C# syntax tree with F#
Jason Rametta - Digging into the .NET Dictionary implementation
Oren Eini - Syncfusion Controls Support .NET 6 and Visual Studio 2022
Mohamed Samsudeen - Custom JSON Serialisation with System.Text.Json Converters
Steve Gordon - Async Disposables The Easy Way
Phil Haack
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Directivas using globales en C# 10
José María Aguilar - Antipatrones de asincronía en C#
José María Aguilar
.NET Core / .NET
- Difference Between "throw" vs "throw ex" in C#
Marinko Spasojevic - What’s New in C# 10: Take Control of Interpolated String Handling
Jason Roberts - Not So Complex Numbers in C#
Mike James - Polymorphic Serialization with .NET System.Text.Json
Khalid Abuhakmeh - Fun with Flags, Enums and Bit Shifting
James Turner - What’s New in C# 10: Value Type Records
Jason Roberts - How Rider Hot Reload Works Under the Hood
Maarten Balliauw - .NET 6 Has Arrived: Here Are a Few of My Favorite Things
Dave Brock - The shortest quine in C# 9 and 10
Martin Zikmund - Windows Forms Lives On in .NET 6
David Ramel
Cuando aparece una nueva versión de C# o .NET, los titulares de las noticias, tweets y posts suelen girar en torno a las novedades más destacadas, aquellas que suponen cambios importantes respecto a versiones anteriores. Pero es habitual que, aparte de éstas, se añadan otras características más pequeñas que muchas veces pasan desapercibidas.
Esto es lo que ocurre con al atributo [CallerArgumentExpression], una joyita de C#10 que puede ayudarnos a hacer más descriptivos los mensajes de error y trazas que guardamos cuando aparece un error en nuestras aplicaciones.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- ¿Por qué llamamos "uppercase" y "lowercase" a mayúsculas y minúsculas?
José María Aguilar - ¿Se pueden asociar varias interfaces a la misma instancia en el contenedor de servicios de ASP.NET Core?
José María Aguilar
.NET Core / .NET
- DateOnly and TimeOnly support with System.Text.Json
Marco Minerva - Updating your project to use File Scoped Namespaces
Gérald Barré - Best keyboard shortcuts for .NET development
Piotr Bach - What’s New in C# 10: Simplify Argument Null Checking Code & Easier Lambda Expressions & New Possibilities for Validation and Logging Methods
Jason Roberts - Bending .NET - Common Flat Build Output
Niels Rasmussen - What’s New in C# 10: Write Less Code and Reduce Repeated Using Directives
Jason Roberts - [CallerArgumentExpression] and throw helpers: Exploring .NET Core 6
Andrew Lock - A .NET 5.0 Guide: From Idea To NuGet Package
Khalid Abuhakmeh - Modern C# Hello World
Patrick Smacchia - How to parse JSON Lines (JSONL) with C#
Davide Bellone - Named Pipes in .NET 6 with Tray Icon and Service
Erik Engberg - dotnet-script 1.3 is out with .NET 6.0 support
Filip Woj - When String.GetHashCode() in .NET C# Drives You Crazy
Ahmed Tarek - Everything That Every .NET Developer Needs to Know About Disposable Types: Using Tools to Find Issues
David McCarter - C# 10 Record Structs
Joe Mayo - Creating an Async Web API with ASP.NET Core
Pro Code Guide - Windows Authentication with HttpClient
Rick Strahl
Estamos muy acostumbrados a comenzar nuestros métodos realizando comprobaciones para evitar que pasen a nuestro código valores nulos que pudieran romper la aplicación.
Desde el principio de los tiempos, estas guardas han presentado el siguiente aspecto:
public class MyService
{
public void MyMethod(object first, object second)
{
if(first == null)
{
throw new ArgumentNullException("first");
}
if(second == null)
{
throw new ArgumentNullException("second");
}
// ...
}
}
¿Todo bien, verdad? El código es aparentemente correcto y fácil de comprender, pero... ¡demasiado extenso! Hemos consumido casi diez líneas de código sólo realizando comprobaciones de "fontanería", y ni siquiera hemos empezado a plantear la funcionalidad real del método.
Afortunadamente, con el tiempo C# ha ido evolucionando y mejorando sucesivamente este escenario tan frecuente.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Publicando nuestra web sobre Azure Web Apps
Jorge Turrado - 5 motivos por los que tus acciones MVC reciben objetos vacíos o nulos en ASP.NET Core
José María Aguilar
.NET Core / .NET
- Más novedades de .NET 6, PriorityQueue
Javier Suárez - 1.0 stable release of Windows App SDK is now LIVE!
Dina Ayman - Infer# v1.2: Interprocedural Memory Safety Analysis For C#
Xin Shi - The Case for C# and .NET
Charles Chen - What's new in Windows Forms in .NET 6.0
Igor Velikorossov - Setting up Serilog in .NET 6
Nicholas Blumhardt - C# 10 new feature CallerArgumentExpression, argument check and more
Dixin Yan - Azure Active Directory's gateway is on .NET 6.0!
Avanindra Paruchuri - Monitoring a .NET application using OpenTelemetry
Gérald Barré - New dependency injection features in .NET 6: Exploring .NET Core 6
Andrew Lock - C# Tip: Use a SortedSet to avoid duplicates and sort items
Davide Bellone - Exploring C# 10: Use Extended Property Patterns to Easily Access Nested Properties
Dave Brock - .NET 6 vs .NET 5: up to 40% speedup!
Alex Yakunin
Hasta Blazor 6, daba la impresión de que la query string era un ciudadano de segunda clase en el sistema de routing, pues no se ofrecían mecanismos sencillos para la obtención de parámetros suministrados a través de esta vía, ni tampoco para la generación de URI que los utilizaran. De hecho, estas tareas teníamos que solucionarlas manualmente, aunque fuera con ayuda de paquetes externos como Microsoft.AspNetCore.WebUtilities.
Ya con la llegada de esta versión, Blazor incorpora de serie herramientas que nos harán esto más llevadero, como su integración con el binding o, lo que veremos en este post, la posibilidad de generar direcciones que incluyan este tipo de parámetros.
Ahí van los enlaces recopilados durante la semana pasada, obviamente muy condicionados por la oleada de lanzamientos de nuevas versiones de casi todo. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Si las shadow properties no existen como propiedades en la entidad, ¿cómo podemos inicializarlas en el seed de Entity Framework Core?
José María Aguilar - CRUD en Blazor usando el componente DataGrid de Syncfusion
José María Aguilar
.NET Core / .NET
- Announcing .NET 6 - The Fastest .NET Yet
Richard Lander - Welcome to C# 10
Kathleen Dollard - What’s New for Visual Basic in Visual Studio 2022
Kathleen Dollard - F# is officially here!
Kathleen Dollard - Announcing dotnet monitor in .NET 6
Sourabh Shirhatti - How to Fully Cover .NET C# Console Application With Unit Tests
Ahmed Tarek - Executing ad hoc C# code snippets
Dominique St-Amand - Bite-Size .NET 6 - UnionBy, IntersectBy, ExceptBy, and DistinctBy
Matthew Jones - Asynchronous Programming in .NET Core C#
Pro Code Guide - Top 6 Features in the new .NET Version & Top 5 Features in the new C# Version
Nikola M. Zivkovic - Source generator updates: incremental generators: Exploring .NET Core 6
Andrew Lock - GIFs in Console Output Using ImageSharp and Spectre.Console
Khalid Abuhakmeh - C# Delegates
Marinko Spasojevic - WhenAny and Pattern Matching with Different Types of Task
Bryan Hogan - C# 10 Falls Just a Bit Short
Matthew MacDonald - Single File Apps In .NET 6
Wade Gausden - How C# 10.0 and .NET 6.0 improve ArgumentExceptions
Ian Griffiths - Dissecting Interpolated Strings Improvements in C# 10
Sergey Teplyakov - Building a project that target .NET Framework 4.5 in Visual Studio 2022
Thomas Levesque - Why Does x = ++x + x++ Give Me the Wrong Answer?
OriginalGriff - Overriding Sealed Methods in C#
Adam Furmanek
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Shadow properties en Entity Framework Core
José María Aguilar - ¿Se pueden crear componentes Blazor que no hereden de ComponentBase o alguno de sus descendientes?
José María Aguilar
.NET Core / .NET
- .NET 6: DateOnly y TimeOnly & File Scoped Namespaces & Global Usings
Javier Suárez - Enums in C#: hidden pitfalls
Sergey Vasiliev - ICYMI C# 9 New Features: Create Immutable Objects with Records
Jason Roberts - .NET Collections - IEnumerable, IQueryable, ICollection
Marinko Spasojevic - Bite-Size .NET 6 - MaxBy() and MinBy() in LINQ
Matthew Jones - Diagnostics tools for App Service on Linux
Mark Downie - Improving logging performance with source generators: Exploring .NET Core 6
Andrew Lock - A quick review of C# 10 new language features
Thomas Levesque - String Performance: Concatenating Strings
David McCarter - Discovering new C# String Pattern Matching Features
Rick Strahl - Caller Argument Expressions – A Look at New Language Features in C# 10
Rachel Appel
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Cómo crear un paquete NuGet y publicarlo en Nuget.org
Jorge Turrado - Expresiones new con el tipo de destino en C# 9
José María Aguilar
.NET Core / .NET
- Calendario común de comunidades .NET de España
Javier Suárez - Google Sheets API with .NET Core
Marinko Spasojevic - Making Sense of Common C# Compiler Errors
Matt Eland - Parallel.ForEachAsync in .NET 6
Scott Hanselman - Bite-Size .NET 6 - PriorityQueue<T, N>
Matthew Jones - Dotnet Format and File Scoped Namespaces
Steve Smith - How to Get Rid of the INotifyPropertyChanged Boilerplate
Gael Fraiteur - How to test HttpClientFactory with Moq
Davide Bellone - Pattern Matching in C# for Beginners
Sowmiya V. - 5x Lessons Learned from Migrating a Large Legacy to .NET 5/6
Patrick Smacchia - Immutable C#
Sam Williams - Moq vs NSubstitute: syntax cheat sheet
Davide Bellone - File-Scoped Namespaces – A Look at New Language Features in C# 10
Khalid Abuhakmeh - What's new in .NET 6 and C# 10. Everything you wanted to know.
Oleksii Nikiforov - Everything That Every .NET Developer Needs to Know About Disposable Types: Properly Implementing the IDisposable Interface
David McCarter - Sorting large CSV files by multiple columns using C#
Josef Ottosson
Hoy va un post rapidito sobre un curioso detalle sintáctico de C# que me llamó la atención hace algún tiempo, mientras leía el artículo How to Stress the C# Compiler, donde Henning Dieterichs comenta varias formas de estresar (¡literalmente!) al compilador de C# utilizando construcciones admitidas por el lenguaje.La cuestión es: ¿por qué no compila el siguiente código?
class Program {
public static void Main() {
int f = 0; int x = 0; int y = 0;
System.Console.WriteLine(
"{0} {1}",
f < x, // is f smaller than x?
y > (-1) // is y greater than -1?
);
}
}Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Crear manualmente instancias de clases usando el proveedor de servicios de .NET
José María Aguilar - Invalidar el contenido cacheado por el tag helper "cache" de ASP.NET Core MVC
José María Aguilar
.NET Core / .NET
- What’s new in F#
Kathleen Dollard - Prefer using Stream to byte[]
Bohdan Stupak - Supporting integration tests with WebApplicationFactory in .NET 6: Exploring .NET Core 6
Andrew Lock - Bite-Size .NET 6 - LINQ OrDefault() Overloads
Matthew Jones - IAsyncEnumerable with yield in C#
Marinko Spasojevic - C# Tip: use the Ping class instead of an HttpClient to ping an endpoint
Davide Bellone - Exploring C# 10: Global Using Declarations
Dave Brock - C# 10.0: Extended Property Patterns – Use the Dot Token to Access Nested Members
Thomas Claudius Huber - How to Create a PNG File with Transparent Background from a Powerpoint Slide in C#
Roland Weigelt - C# Records - The good, bad & ugly
Gary Woodfine
