Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- ¿Qué es Blazor, eso de lo que todo el mundo habla?
José María Aguilar - Cómo reconocer a los buenos desarrolladores
José María Aguilar
.NET Core / .NET
- Set C# Language Version for All the Projects in a Solution
Bartosz Jarmuż - Getting telemetry data from inside or outside a .NET application
Gérald Barré - How to install and test nuget packages locally
Gary Woodfine - Case Study: Double performance in under 30 minutes
Nik Karpinsky - Techniques and tools to update your C# project - Migrating to nullable reference types
Maarten Balliauw - Using HTTPListener to build a HTTP Server in C#
Nick Charlton - Upgrading a WCF service to .NET 6 with CoreWCF
Mike Rousos - Microsoft Graph's Journey to .NET 6
Joao Paiva - Challenge: Spot the optimization & Challenge: Spot the optimization–solution
Oren Eini - Quickly Map Your NuGet Packages to Sources
Erdembayar Yondon - Generating sortable Guids using NewId
Andrew Lock - One step beyond by using .NET Collections to its fullest
Ioannis Kyriakidis - On awaiting a task with a timeout in C#
Raymond Chen - Forcing HttpClient to use IPv4 or IPv6 addresses
Gérald Barré - Hacking C# - Adjustable arrays
Simon Painter
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- ¿Recomendarías a tu hijo que se dedicase al mundo del desarrollo de software?
José María Aguilar - Incluir recursos estáticos en una Biblioteca de Clases Razor (RCL)
José María Aguilar
.NET Core / .NET
- Dockerfile para .Net 6
Fernando Escolar - CoreWCF 1.0 has been Released, WCF for .NET Core and .NET 5+
Sam Spencer - C++ For C# Developers: Part 1 – Introduction
Jackson Dunstan - How to generate Fake data in C#?
Karthik Chintala - Annotating your C# code - Migrating to nullable reference types
Maarten Balliauw - Create .NET Objects without Calling The Constructor
Khalid Abuhakmeh - Sharing coding style and Roslyn analyzers across projects
Gérald Barré - Different Ways to Implement IHttpClientFactory in .NET Core Apps
Mahesh More - Using User Secrets Configuration In .NET
Wade Gausden - C#: Add event handlers dynamically using reflection
Mike Hadlow
Imaginad que tenemos un controlador MVC como el siguiente:
public class TestController : Controller
{
public IActionResult Add(int a, int b)
{
return Content($"Result: {a + b}");
}
}
Claramente, la acción Add() retornará la suma de los enteros a y b que le llegarán como parámetros de la query string:
GET https://localhost:7182/test/add?a=1&b=2 HTTP/1.1
HTTP/1.1 200 OK
Content-Type: text/plain; charset=utf-8
Result: 3
Pero, como sabemos, podríamos llamar a la acción sin indicar alguno de esos parámetros, o incluso ninguno de ellos:
| Petición | Respuesta |
|---|---|
| GET /test/add?a=1&b=2 | Result: 3 |
| GET /test/add?a=0&b=0 | Result: 0 |
| GET /test/add?a=1 | Result: 1 |
| GET /test/add | Result: 0 |
Esto es así porque el binder será capaz de poblar correctamente los parámetros a y b cuando estén presentes en la cadena de la petición y sean correctos, o les asignará su valor por defecto (0) cuando no hayan sido suministrados.
Pero dado que el cero es un valor de entrada válido, a priori desde nuestro código no tendríamos forma de distinguir cuándo el parámetro ha sido omitido y cuándo se ha establecido expresamente.
¿Cómo podríamos hacerlo?
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- 7 Hábitos de personas altamente innovadoras
José María Aguilar - Streaming en gRPC, parte II: Streaming bidireccional
José María Aguilar
.NET Core / .NET
- ¿Se ha vuelto demasiado complejo C#?
Eduard Tomás - Cómo manejar JSON en .NET con System.Text.Json
José Manuel Alarcón - Ejemplo de un método deshonesto en C# .NET y cómo refactorizarlo
Albert Capdevila - C# 11 Preview Updates - Raw string literals, UTF-8 and more!
Kathleen Dollard - A Time-Scoped Registration Mechanism for Microsoft.Extensions.DependencyInjection
David Kröll - Running JavaScript inside a .NET app with JavaScriptEngineSwitcher
Andrew Lock - Internals of C# nullable reference types - Migrating to nullable reference types
Maarten Balliauw - Using dotnet format Command to Format the C#/.NET Code
Ryan Miranda - C# async await explained
Patrick Smacchia - Building a NuGet Packages Architecture Part 6 - Enhancing your packages
Imar Spaanjaars - C# Tip: How to temporarily change the CurrentCulture
Davide Bellone - Async and Async Void Event Handling in WPF
Rick Strahl - C# Code Rules
Christian Findlay - Running and Debugging Multiplatform .NET Core (.NET5 or .NET6) GUI and Console Applications on Windows Subsystem for Linux (WSL)
Nick Polyak
La semana pasada veíamos algunas alternativas para comprobar de forma eficiente si una cadena de texto contiene un JSON válido y, al hilo de dicho post, el amigo Javier Campos aportó vía Twitter una fórmula adicional mejor que las que vimos aquí.
El código en cuestión es el siguiente:
public bool IsJsonWithReader(string maybeJson)
{
try
{
var reader = new Utf8JsonReader(Encoding.UTF8.GetBytes(maybeJson));
reader.Read();
reader.Skip();
return true;
}
catch
{
return false;
}
}
La estructura Utf8JsonReader ofrece una API de alto rendimiento para acceder en modo forward-only y read-only al JSON presente en una secuencia de bytes UTF8. Los métodos Read() y Skip() se encargan respectivamente de leer el primer token del JSON y saltarse todos sus hijos, con lo que en la práctica se recorrerá el documento completo, lanzándose una excepción en caso de ser inválido.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Streaming en gRPC, parte I: Streaming unidireccional
José María Aguilar - Variables locales implicítamente tipadas en C#
José María Aguilar
.NET Core / .NET
- Announcing .NET 7 Preview 3
Jon Douglas - Nullable reference types in C# - Migrating to nullable reference types
Maarten Balliauw - Getting Disk information in Windows with C#
Bruno Sonnino - Reflected Image in C# with GDI and Unchecked Code
AdventureDriver - .NET Automatic Updates for Server Operating Systems
Jamshed Damkewala - Keeping up with .NET: learning about new features and APIs
Andrew Lock - Adding Alt Text To Twitter Images Using C#
Khalid Abuhakmeh - Warning on lower case type names in C# 11
Jared Parsons - Faster .NET development on Kubernetes with Skaffold
Salvatore Merone - Introducing Central Package Management
Jeff Kluge - Using the Roslyn APIs to Analyse a .NET Solution
Steve Gordon - Deep C# - Interface
Mike James - Discussing alternative memory management strategy for .NET
Mark Pelf - Dissecting AutoMapper Programming Horror
Jimmy Bogard - Ignoring JSON Key Casing and Numbers as Strings when Deserializing with System.Text.Json
Bryan Hogan
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Ojo con la inicialización de propiedades usando expression bodied members
José María Aguilar - 13 Consejos para comentar tu código
José María Aguilar
.NET Core / .NET
- .NET Framework 4.5.2, 4.6, and 4.6.1 will reach End of Support on Apr 26, 2022
Jamshed Damkewala - How to prevent Email HTML injection in C# and .NET
Niels Swimberghe - Implementing OAuth2 Client credentials flow APP to APP security using Azure AD non interactive
Damien Bowden - GDI/User Object Leak Tracking – The Easy Way
Alois Kraus - Creating and Using HTTP Client SDKs in .NET 6
Oleksii Nikiforov - Must-Know Concepts Related to LINQ and IEnumerable
Ioannis Kyriakidis - How segments and regions differ in decommitting memory in the .NET 7 GC
Maoni Stephens - C# Pattern Matching Explained
Patrick Smacchia - C# Tip: Use Debug-Assert to break the debugging flow if a condition fails
Davide Bellone - Value types and exceptions in .NET profiling
Christophe Nasarre - Forcing HttpClient to use IPv4 or IPv6 addresses
Gérald Barré - Challenge: Why is this code broken?
Oren Eini - Speed Up Logging in .NET
David McCarter
Al hilo del post Cómo recibir un JSON como string en una acción ASP.NET Core MVC, el amigo Alberto dejaba una interesante pregunta en los comentarios: ¿y si una vez hemos recibido el string, queremos validar que sea un JSON válido?
Obviamente, una forma sencilla sería intentar deserializarlo por completo a la clase de destino, siempre que ésta sea conocida. Para ello podríamos utilizar el método Deserialize<T>() del objeto JsonSerializer de System.Text.Json, disponible en todas las versiones modernas de .NET, de la siguiente manera:
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Evitar el postback al pulsar un botón en ASP.Net
José María Aguilar - Implementación de servicios gRPC con ASP.NET Core
José María Aguilar
.NET Core / .NET
- What’s up with TimeZoneInfo on .NET 6? (Part 2)
Jon Skeet - Using PowerPoint as a WYSIWIG Editor for HTML Templates (Proof of Concept in C#)
Roland Weigelt - Search videos through the YouTube Data API from C#
Thomas Ardal - Converting code to the new Regex Source Generator
Gérald Barré - Tracking down a hanging xUnit test in CI: building a custom Test Framework
Andrew Lock
A veces, sobre todo en aplicaciones muy grandes, con las definiciones de rutas muy complejas o cuando nos toca analizar aplicaciones ajenas, puede ser interesante saber qué punto del código está procesando una petición determinada, ya sea un endpoint definido usando Endpoint Routing o Minimal APIs o bien sea una acción de un controlador MVC.
En este post vamos a ver cómo conseguirlo de forma muy sencilla, mediante la implementación un pequeño middleware que, insertado en el pipeline, añadirá en el encabezado información sobre el handler que generó la respuesta de la petición actual.
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.
