Aquí van los enlaces recopilados durante la semana pasada, en lo que será ya la última entrega del año. Volveremos a las tareas de recolección la primera semana de enero, semana arriba o semana abajo (¡soy malo para esto de las estimaciones!😉).
Esta edición incluye enlaces a casi 50 contenidos que me han llamado la atención, aunque me gustaría resaltar especialmente algunos de ellos.
En primer lugar un gran repaso de CampusMVP a los CWE Top 25 de 2024 o, en otras palabras, a los principales agujeros de seguridad que dejamos por detrás los desarrolladores al crear nuestras aplicaciones. Algunos de ellos seguro que los conoces ya, como inyección SQL o XSS, pero hay muchas más perversidades que debemos conocer y evitar.
Muy interesante, como siempre, los resultados publicados por JetBrains sobre el estado del ecosistema de desarrolladores del año que está a punto de terminar, obtenidos de una encuesta a más de 23.000 developers de todo el mundo. Aquí encontraréis información valiosa sobre los proyectos en los que más trabajamos, qué lenguajes son los más utilizados en distintas áreas, qué herramientas son las preferidas, o si seguimos pensando que la IA nos va a quitar el trabajo a todos los desarrolladores antes de acabar totalmente con la humanidad, o si en cambio es una gran aliada 😉
Por último, también me parece destacable los anuncios que Microsoft ha dejado caer hace unos días: la disponibilidad de un nuevo plan gratuito de GitHub Copilot para los usuarios de Visual Studio y Visual Studio Code. Bueno, obviamente tiene sus limitaciones, pero es un buen punto de partida para los que aún no habéis podido probarlo o no tenéis acceso a licencias superiores.
Por último, aprovecho también para desearos a todos unas muy felices fiestas. Disfrutad de la mejor compañía posible y pasadlo bien, pero eso sí, sin excesos, que luego vienen los arrepentimientos... 😉
Por si te lo perdiste...
- Serialización polimórfica con System.Text.Json
José M. Aguilar - Cómo saber si un nivel de traza está activo en aplicaciones ASP.NET Core/MVC
José M. Aguilar
.NET Core / .NET
- .NET Framework Migration to .NET 9
Derek Comartin - Some news about .NET 10: BackgroundServices and new String Comparer
Steven Giesel - Deep C# - The Perils of the C# Parallel For
Mike James - How and why to write mutation tests in C#
Daniel Ward - Special properties in .NET projects
Alexandre H. T. R. - Deserializing JSON to a string or a value
Phil Haack - Functional Programming With C# - Make Dictionaries Functional!
Simon Painter - C# 13 and .NET 9: Personal Highlights
Dmytro Misik
A principios de siglo, con un C# aún bastante primitivo, las propiedades que almacenaban datos en una clase teníamos que definirlas siempre usando un backing field, es decir, un campo privado que almacenaba el valor, y accediendo a él mediante métodos getter y setter. Es decir, algo así:
public class Customer
{
private string _name;
public string Name
{
get { return _name; }
set { _name = value; }
}
...
}
Esto cambió en 2007 con la llegada de las propiedades automáticas, una maravilla para nuestros cansados dedos, que desde entonces usamos en la mayoría de ocasiones. Gracias a ellas, podemos definir una propiedad sin tener que implementar sus métodos accesores ni su campo privado correspondiente, porque el compilador se encargaba de crearlos por nosotros. De esta forma, código anterior quedaba así:
public class Customer
{
public string Name { get; set; }
...
}
En realidad, se trataba sólo de un azucarillo sintáctico. Por detrás, el compilador está generando el campo privado y transformando nuestro código para utilizarlo; de hecho, el código generado de la clase anterior es algo así (algo simplificado para que se pueda leer mejor):
public class Customer
{
private string <Name>k__BackingField;
public string Name
{
get { return <Name>k__BackingField; }
set { <Name>k__BackingField = value; }
}
}
Aunque obviamente usar propiedades automáticas es mucho más cómodo que la opción anterior, tiene un inconveniente: no tenemos forma de acceder al campo generado por el compilador, algo que puede resultar interesante si nos interesa realizar algún tipo de validación o lógica adicional en el getter o setter más allá de simplemente devolver o asignar el valor.
Por ejemplo, imaginemos que queremos que el nombre de nuestro cliente siempre esté en mayúsculas. Con una propiedad automática, simplemente no podemos hacerlo, y tendremos que recurrir a las verbosas propiedades tradicionales con backing fields.
Y aquí es donde entran en escena las propiedades semiautomáticas...
Esta semana la cosecha ha sido especialmente prolífica y traemos más de 70 enlaces a contenidos que creo que vale la pena echar un vistazo, como siempre, categorizados por área de interés: .NET, ASP.NET Core, Azure, patrones y buenas prácticas, acceso a datos, inteligencia artificial, programación web (HTML, CSS, Javascript...), herramientas de desarrollo, .NET MAUI y otros.
Como vengo haciendo últimamente, me gustaría destacar el gran post de José Manuel Alarcón sobre técnicas de carga especulativa en páginas web que te ayudarán a mejorar el rendimiento de las aplicaciones.
Muy bueno también el deep dive de Ricardo Peres sobre los tokens de cancelación de tareas, a veces unos grandes desconocidos.
Por último, dos avisos a navegantes: primero, David Grace nos recuerda que en .NET 9, los proyectos de APIs ya no incorporan por defecto Swagger y propone algunas alternativas, y, segundo, Steve Smith alerta de los peligros de usar eventos de .NET en aplicaciones ASP.NET Core y aporta opciones para conseguir lo mismo.
Todo esto, y mucho más, a continuación...
Por si te lo perdiste...
- Binding de parámetros en Minimal APIs con BindAsync
José M. Aguilar - Añadir automáticamente maxlength a inputs usando tag helpers en ASP.NET Core MVC
José M. Aguilar
.NET Core / .NET
- Announcing .NET Community Toolkit 8.4
Sergio Pedri - Understanding Multidimensional Arrays in C#
Rohan Rao - Recurring Tasks in .NET C# : All options explained
Zied Rebhi - Why IActorRef.Tell Doesn't Return a Task
Aaron Stannard - Manually Implementing an Identity Store for Asp.Net Identity
Paul Michaels - Extracting Icons From A Windows DLL Or EXE With C#
Den Delimarsky - LINQ might get a "left join" operator in .net 10
Steven Giesel - Using vectorization in C# to boost performance
Brant Burnett - Inside a Where() - Understanding IEnumerables
James Curran - Object Pools in C#: Examples, Internals and Performance Benchmarks
Alexey Fedorov - Invoking Async Power: What Awaits WinForms in .NET 9
Michael Taylor - Using the YamlDotNet source generator for Native AOT
Andrew Lock - How To Replace Exceptions with Result Pattern in .NET
Anton Martyniuk - Easily Convert Excel to HTML in 3 Steps With C#
Kurmitha Manickhaperumal - Ultra: An advanced profiler for .NET Applications on Windows
Alexandre Mutel - The State of Aspect-Oriented Programming in C# [2025]
Metalama Team - What's New in .NET 9 and C# 13
Ricardo Peres - C# 12: The Experimental Attribute
Thomas Claudius Huber - Meet TUnit: The New, Fast, and Extensible .NET Testing Framework
Sander ten Brinke - The Ultimate Guide to .NET Environment Variables
Hatim Rih - Efficient searching in .NET with SearchValues
Bart Wullems - The attribute OverloadResolutionPriority in .NET 9 and C# 13
NDepend Team - More Testing Tips With C#
Roman Stoffel - MessagePack for C# v3 Release with Source Generator Support
Yoshifumi Kawai - .NET Cancellation Tokens
Ricardo Peres - Avoid Using C# Events in ASP.NET Core Applications
Steve Smith
Aunque un día más tarde de lo normal debido al puente, aquí van los tradicionales enlaces recopilados durante la semana pasada. Como es habitual, la mayoría de los enlaces son a contenidos en inglés, pero también hay algunos en español que me gustaría destacar en esta ocasión.
Por una parte, Jose Manuel Alarcón explica cómo clonar superficialmente un repositorio GIT (shallow clone) para obtener sólo los últimos commits y ahorrar tiempo y espacio en disco.
También muy interesante el post de Braulio Díez, donde reformula la clásica regla del Boy Scout y, quitándole algo de épica romántica, nos recuerda que a veces no siempre es buena idea tocar donde no debemos, o hacerlo de cualquier forma.
Y ahora, vamos a por el resto...
Por si te lo perdiste...
- Eliminaciones y actualizaciones masivas (bulk deletes/updates) con EF Core 7
José M. Aguilar - Confluencia de ramas en el pipeline de ASP.NET Core
José M. Aguilar
.NET Core / .NET
- From .NET 6 to .NET 8, my migration experience:Fixing missing x-forwarded headers in .NET 8 isolated Azure Functions
Anthony Giretti - Using Testing.Platform with NET 9
Dennis Frühauff - Polymorphic deserialization with YamlDotNet
Anthony Simmon - Faster Dictionary in C#
NDepend Team - C# Tip: 2 ways to generate realistic data using Bogus
Davide Bellone - Lesser known CLR GC Handles
Austin Wise - Typemock Isolator 9.3.3: Embracing .NET 9 and C# 13 with AI Testing Capabilities
Eli Lopian - Choosing the Best Mapping Library for Your .NET Core Project
Muthukumar Thevar - C# Advent: No one loves the .NET Core name anymore
Stephen Cleary - Metadata Consulting [dot] ca: Get the number of columns in an HTML Table using Regex
Metadata Consulting
Hoy me voy a salir un poco de las temáticas habituales para compartir un pequeño truco que llevaba buscando desde hace meses, pero que hasta ahora no había tenido tiempo de investigar.
Como seguro os ocurre a muchos de vosotros, tengo un par de cuentas de Gmail (personal y profesional) y estoy habitualmente saltando de una a otra para gestionar los correos y calendarios. He intentado durante bastante tiempo usar herramientas de escritorio de Windows para gestionar el mail y la agenda de ambas cuentas, pero no he conseguido dar con ninguna que me convenciera del todo, así que he llegado a la conclusión de que realmente la mejor interfaz para Gmail o Google Calendar está en la web.
Pero por otro lado, no me gusta usarlas directamente desde el navegador, así que la opción de instalarlas como aplicaciones web progresivas (PWA) me parecía la mejor solución. Basta con acudir a la página que queremos instalar, por ejemplo https://mail.google.com, abrir el menú de Chrome, acceder a la opción "Enviar, guardar y compartir > Instalar página como aplicación..." y listo. Durante el proceso, incluso se nos pregunta si queremos anclar la aplicación a la barra de tareas, así que podremos tener muy a mano un acceso directo a la aplicación.
El problema es que, al instalarlas, se abren siempre con el usuario de Google que tengamos configurado como por defecto. En la práctica, la aplicación anclada se abrirá siempre con la misma cuenta, que es aquella con la que nos logamos primero en el navegador. Y esto es un problema si queremos tener acceso rápido a varias cuentas, como es el caso.
Es lunes, así que vamos a por los enlaces interesantes de la semana. Quizás algo más escasos que otras veces, probablemente debido a la festividad de acción de gracias del otro lado del charco, pero aún así tenemos una buena colección 🙂
Esta semana, me ha llamado la atención a una interesante pregunta: ¿cuánta memoria necesitarías para ejecutar un millón de tareas concurrentes? Así a ojo es imposible saberlo, pero hay quien ha hecho la prueba con muchos lenguajes, y vemos que C# no sale nada mal parado.
También es un must read el post "¿Y qué trae de nuevo Angular 19?", donde Jose Manuel Alarcón se ha tomado la molestia de recopilar todas las novedades y explicarlas con gran detalle.
Por último, mi descubrimiento de la semana: los bloques de alertas en Markdown. Markdown es mi formato favorito para escribir un montón de cosas (entre otras, los posts de este blog) y era algo que desconocía y me ha parecido bastante interesante y práctico.
Y ahora, a por el resto de enlaces. ¡Espero que los disfrutes! 😊
Por si te lo perdiste...
- Usar dos claves distintas para buscar en un diccionario de .NET
José M. Aguilar - Ramificar el pipeline de ASP.NET Core con Map() y MapWhen()
José M. Aguilar
.NET Core / .NET
- Introducing Microsoft.Extensions.VectorData Preview
Sarosh Wadia - How to Create SVG Files Programmatically in C# .NET
Paarisha Rana - Fire-and-Forget Methods in C# — Best Practices & Pitfalls
Syed Shahriyar - What's new in .NET 9? Key features you need to know!
David Grace - How to Create Command Line Console Applications in .NET
Anton Martyniuk - How to Schedule and Automate C# .NET Reports
Alec Gall - C# 12.0: inline arrays
Ian Griffiths - Checking whether a URI refers to a Web site root
Raymond Chen - idunno.Bluesky: A .NET class library for the the Bluesky social network
Barry Dorrans
Cuando estamos usando alguna clase de .NET en nuestro código, a veces tenemos interés o necesidad de ver qué hace por dentro, para lo que nos gustaría tener acceso rápido a su código fuente. Aunque los IDEs modernos disponen en muchos casos de herramientas o extensiones que lo permiten, está bien saber que hay otras fórmulas sencillas para conseguirlo muy rápida y cómodamente.
Hace poco me he topado con una de ellas, que me ha parecido muy útil y quería compartirla con vosotros, por si hay alguien más que aún no la conoce: la página https://source.dot.net.
Una semana más, vamos con los contenidos interesantes que he ido encontrando por la red. Esta vez, entre los más de 50 enlaces de la entrega, me gustaría destacar tres de ellos.
En primer lugar, el trabajazo de José Manuel Alarcón para resumir todas las novedades de .NET 9 en un único y magnífico artículo. Si queréis poneros al día en unos minutos, no os lo perdáis.
También me ha resultado interesante el post sobre Web Share, una API JavaScript que desconocía, sencillísima de utilizar, relativamente bien soportada en los navegadores, y que puede sernos útil para facilitar la compartición de contenido en nuestras aplicaciones web.
Por último, a modo de homenaje porque durante años ha sido una valiosa fuente de contenidos e información para muchos, me gustaría destacar la semi-despedida de CodeProject, un sitio que si lleváis unos añitos en esto seguro que habéis visitado más de una vez para consultar algunos de sus casi 66.000 artículos técnicos para desarrolladores. Aunque de momento seguirá en línea en modo de sólo lectura, de alguna forma, el post CodeProject is changing anuncia el fin de una era.
Y ahora, vamos con el resto de contenidos que, como siempre, espero que os resulten interesantes.
Por si te lo perdiste...
- Patrones de listas (list patterns) en C# 11
José M. Aguilar - Archivos estáticos en aplicaciones ASP.NET Core (II)
José M. Aguilar
.NET Core / .NET
- .NET 9 ya está aquí: qué novedades trae y qué esperar de esta versión
José M. Alarcón Aguín - How to Turn On Features in .NET and C# Without Redeploying: Exploring Feature Flags and A/B Testing
Ottorino Bruni - Install and use Microsoft Dot NET 9 with the Raspberry Pi
Peter Gallagher - Early Binding and Late Binding in C#
Karthikeyan N. S. - C# 13 - New features and how you can use them now!
David Grace - Boost Your .NET Projects: Unleashing the Power of Spargine’s Numeric Extension Methods
David McCarter - How to Effectively Use Formulas in Excel Using C#
Kurmitha Manickhaperumal - How to Benchmark Your Code in C#
Grant Riordan - Embeded languages in string values supported by Roslyn
Gérald Barré - Schedule Background Job using Quartz.NET
Ali Hamza Ansari - dotnet scaffold - Next Generation Project Creation for .NET
Sayed Ibrahim Hashimi - Easy logging management with Seq and ILogger in ASP.NET
Davide Bellone
Me encanta LINQ. Bueno, ciertamente la sintaxis de consultas integrada en el lenguaje no la uso desde hace muchísimos años, pero los métodos de extensión que proporciona son una maravilla para recorrer y operar sobre colecciones de datos en memoria o almacenados en sistemas externos.
LINQ ha sido uno de los objetivos de .NET 9. Además de mejorarlo internamente y optimizar su rendimiento (en algunos casos, considerablemente), se han incluido tres nuevos métodos, CountBy(), AggregateBy() e Index(), que amplían las posibilidades que teníamos hasta el momento, simplificando la escritura de código y aumentando su legibilidad en algunos escenarios.
Vamos a verlos en detalle.
Como todos los lunes, vamos con los enlaces a contenidos interesantes que he ido encontrando por la red.
Esta semana se ha publicado .NET 9, por lo que tenemos bastantes contenidos relacionados con el lanzamiento y novedades que encontramos en la nueva versión.
Aparte, me ha llamado la atención el post "Understanding LLMs from Scratch Using Middle School Math" de Rohit Patel, que explica cómo funcionan los modelos de lenguaje de gran tamaño (LLMs) de forma sencilla, sin grandes complicaciones matemáticas. Muy recomendable para comprender lo que se cuece bajo el capó de estas tecnologías tan fascinantes.
Y en la sección "hay gente pa tó", me ha parecido curioso el artículo "HTML: The Programming Language", una implementación de un lenguaje Turin completo con sintaxis HTML. Muy útil no parece, pero desde luego es original 😉
Por si te lo perdiste...
- ¡No uses List<T> si siempre vas a buscar por clave en los elementos en una colección!
José M. Aguilar - Archivos estáticos en aplicaciones ASP.NET Core (I)
José M. Aguilar
.NET Core / .NET
- Announcing .NET 9
.NET Team - Calling methods is easier and faster with C# 13 params collections
Kathleen Dollard - Nullable Reference Types in
Tomáš Grošup - Consuming VSIX metadata from C#
Daniel Cazzulino - How to Use Pointers in C#
Konstantinos Polychronopoulos - Functional Programming in C#: The Practical Parts
Milan Jovanović - Traversals
Mark Seemann - How to Set Semantic Versioning for .NET Core Apps and Libraries
Naveed Ausaf - Exploring C# Records and Their Use Cases
Ali Hamza Ansari - Building Rock-Solid Business Logic and Validation Rules in .NET Workflows
Hatim Rih - .NET and C# Versions - 9/13 Update
Niels Rasmussen - Authentication and Authorization Enhancements in .NET 9.0
Andrea Chiarelli - Jeremy Bytes: The C# "field" Keyword and Visual Studio Tooling
Jeremy Clark - Day-0 Telerik Support for .NET 9
Sam Basu
Hace unas semanas estuvimos echando un vistazo a HybridCache, la alternativa de .NET 9 al sistema de caché distribuida que apareció con .NET Core años atrás. Como vimos entonces, HybridCache aporta una serie de ventajas respecto a su predecesor, como la protección contra estampidas, la caché multinivel, invalidación por etiquetas, y otras mejoras.
Sin embargo, también introduce algunos inconvenientes que debemos tener en cuenta si queremos sacarle el máximo partido. En esta ocasión, nos centraremos en la penalización debido a excesiva deserialización de objetos de la caché local, un detalle que puede pasar desapercibido pero que puede tener un impacto significativo en el rendimiento de nuestra aplicación.
Con el horno aún humeante, aquí van los enlaces que hemos estado cocinando durante la semana pasada. Espero que estén en su punto y os resulten de provecho 😉
Especialmente destacable el repaso de José Manuel Alarcón a los eventos que podemos usar en JavaScript para detectar que la página actual deja de estar activa, ante la próxima desaparición del evento 'unload'.
Y si queréis experimentar una buena explosión mental, no os perdáis el post sobre Quines, programas cuya salida es su propio código fuente. Un auténtico desafío para mentes inquietas hartas de programación tradicional y algo de tiempo libre😆
Por si te lo perdiste...
- Prueba APIs fácilmente con el nuevo cliente HTTP integrado en Visual Studio 2022
José M. Aguilar - Acceder a arrays en settings JSON de ASP.NET Core
José M. Aguilar
.NET Core / .NET
- Integration Tests en .NET con TestContainers: Pruebas de Base de Datos Aisladas
Isaac Ojeda - Get Ready for .NET Conf 2024!
Jeffrey Fritz - The Legacy Coder's Guide to .NET Conf 2024
DeeDee Walsh - Avoid AutoMapper, Using GitHub Copilot to Map Entities and DTOs in C#
Hatim Rih - yantra: JavaScript Engine for .NET Standard
Akash Kava & otros - Task.Factory.StartNew and long running async tasks
Sergey Teplyakov - Recent updates for NetEscapades.EnumGenerators: interceptors!
Andrew Lock - 6 Effective Ways to Merge PDF Files Using C#
Chinnu Muniyappan - Display SSRS Report in .NET Core Application
Sebastiao Pereira - C# Records
Paul Michaels - Easily Create Dynamic Charts in Excel Using C#
Kurmitha Manickhaperumal - 4 Ways to Implement ICommand
Metalama Team - Getting the Current TabItem when the Tab is not selected in WPF
Rick Strahl - How dotnet.exe resolves and loads the hostfxr library – Exploring the .NET muxer
Steve Gordon - Working With DTO Auto Translators
Peter Ritchie
La clase Task de .NET dispone de algunos métodos estáticos para trabajar con colecciones de tareas de forma sencilla. Uno de ellos es Task.WhenAll(), que nos permite esperar a que todas las tareas que le pasemos como argumento se completen, o Task.WhenAny() para esperar a que finalice sólo alguna de ellas.
Sin embargo, hasta ahora no existía una forma sencilla y directa de procesar las tareas conforme se fueran completando. O bien esperábamos a que todas finalizaran con Task.WhenAll(), o bien teníamos que crear un bucle que fuera esperando la finalización de la siguiente tarea con Task.WhenAny(), saliendo cuando todas hubieran acabado.
Afortunadamente, .NET 9 ha añadido el nuevo método llamado Task.WhenEach() que lo pone más fácil, permitiéndonos detectar sobre la marcha la finalización de las tareas conforme va ocurriendo. Esto nos facilita el proceso de sus resultados secuencialmente, en el orden en el que se completan y sin esperar a que acaben todas.
Vamos a verlo, pero para entenderlo mejor, primero vamos a recordar las opciones que teníamos antes de la llegada de este método.
Ya tenemos aquí los enlaces recopilados durante la semana pasada 🙂
Aunque hay bastante chicha, me ha llamado especialmente la atención que cumpla 21 años una herramienta que sigue siendo imprescindible en el cinturón de muchos de nosotros: Notepad++. ¡Felicidades a Don Ho y los más de 350 colaboradores que lo hacen posible!
Por si te lo perdiste...
- ¿Cuál es el "Bus factor" de tu proyecto?
José M. Aguilar - ¿Compila este código C#? Y si es así, ¿qué retorna?
José M. Aguilar
.NET Core / .NET
- Has Ruby-on-Rails-Style 'Gem Glue-Gunning' Come to .NET?
Aaron Stannard - Personal Identifiable Information Masking in Marten
Jeremy D. Miller - Is the result pattern worth it?
Andrew Lock - Boost .NET 8 Performance with Native AOT
Hatim Rih - Named HttpClient Registrations
Ricardo Peres - 4 Ways to Implement INotifyPropertyChanged – PostSharp Blog
Metalama - C# 12.0: primary constructors | endjin - Azure Data Analytics Consultancy UK
Ian Griffiths
Seguimos analizando las novedades de .NET 9, y en esta ocasión le toca el turno a la actualización en miembros de clases parciales de C# 13.
Las clases o tipos parciales de C# están con nosotros casi desde los inicios de .NET, desde los tiempos de C# 2.0. Como sabemos, éstas permiten dividir la implementación de un tipo en varios archivos. Su existencia se debía a varios motivos:
- Permitir a los desarrolladores trabajar en clases de forma concurrente sin bloquearse (recordemos que por aquellos tiempos aún pululaban por ahí infames sistemas de control de código fuente como SourceSafe).
- Trocear clases extensas para facilitar su comprensión y mantenimiento.
- Y, el que es más importante, posibilitar el uso sencillo de herramientas de generación de código que, de alguna forma, tuvieran que completar la implementación de código del usuario.
Acompañando a las clases parciales, se introdujo también el soporte para métodos parciales. Aunque su uso era limitado y podía depararnos algunas sorpresas, eran útiles para comunicar de forma segura distintos fragmentos de la clase. Básicamente, consistía en que una porción de una clase podía definir un método e invocarlo desde su código, delegando a otras porciones su implementación. Si no se implementaba en ninguna otra parte, simplemente no se generaba el código de la invocación.
Veamos un ejemplo del uso de estas características:
// Archivo: Ejemplo.Main.cs
public partial class Ejemplo
{
// El método parcial se declara sin implementación...
partial void Log(string msg);
public void RealizarAlgo()
{
hacerAlgoComplejo();
Log("¡Ojo!"); // Usamos el método
// parcial declarado antes
}
}
// Archivo: Ejemplo.Log.cs
public partial class Ejemplo
{
partial void Log(string msg)
{
Console.WriteLine(msg);
}
}
Pues bien, casi dos décadas más tarde, los tipos parciales van a recibir algunas actualizaciones interesantes en C# 13, posibilitando que, además de métodos, puedan definirse propiedades parciales.
Aquí tenéis los enlaces recopilados durante la semana.
En esta ocasión, creo que como mínimo vale la pena echar un vistazo a lo nuevo de Anthropic, que sorprende especialmente con computer use, una vuelta de tuerca más para la automatización de tareas con nuestro ordenador. Es increíble que hace sólo unos meses, todas estas novedades que van apareciendo sólo podrían haber cabido en la ciencia ficción...
También muy interesante el movimiento de JetBrains, facilitando el uso gratuito de sus IDEs WebStorm y Rider para proyectos no comerciales 🙂
¡Que los disfrutéis!
Por si te lo perdiste...
- Eliminar el encabezado "X-Powered-By" en ASP.NET Core
José M. Aguilar - Cómo enviar mensajes a la consola del navegador desde Blazor
José M. Aguilar
.NET Core / .NET
- .NET 9 Feature Switches: Trimming the Fat (Like Your Code, Not You)
Cheyenne Sokkappa - Sending Messages to the Original Sender with Wolverine
Jeremy D. Miller - Adding more extensions to Result<T>
Andrew Lock - What are the SOLID Principles in C#? Explained With Code Examples
Danny Adams - Upgrade Your Windows Forms .NET Projects to the Latest .NET Version for Enhanced Security
Shyam Gupta - 10 Most Frequently Asked Questions About JWT in .NET & Implementing JWT Authentication in ASP.NET Core – ArgosCo .net Development Blog
Hatim Rih - A Brief Introduction to the .NET Muxer (aka dotnet.exe)
Steve Gordon
Una de las novedades más destacables de .NET 9 es, sin duda, el nuevo sistema de caché híbrida (Hybrid cache), una puesta al día del sistema de caché distribuida que nos acompaña desde las primeras versiones de .NET Core, y al que iban haciendo falta ya algunas mejoras.
Este nuevo sistema está construido encima de la infraestructura de caching existente (Microsoft.Extensions.Caching), añadiendo mejoras que hacen que su uso sea más sencillo y contemplando de serie funcionalidades que antes nos veíamos obligados a implementar manualmente.
Vamos a echarle un vistazo a sus principales características :)
Disclaimer: lo que vamos a ver a continuación está basado en .NET 9 RC2, por lo que todavía es posible que haya cambios en la versión final.
Como todos los principios de semana, aquí va la lista de enlaces recopilados durante los últimos siete días. Hay bastantes cosas que me han llamado la atención en esta ocasión; entre otros, he descubierto que Visual Studio incluye un visualizador de JWT integrado, el atributo [OverloadResolutionPriority] de .NET 9/C#13, y también me he preguntado cuántos son muchos índices en una tabla SQL 😕
Por si te lo perdiste...
- Añadir o eliminar encabezados de respuesta en ASP.NET Core y Core MVC
José M. Aguilar - Obtener el valor de parámetros de la query string con JavaScript
José M. Aguilar
.NET Core / .NET
- Runnable examples
Sergio León - Trace sampling in SerilogTracing
Nicholas Blumhardt - What's new in System.Text.Json in .NET 9
Eirik Tsarpalis - Safety and simplicity with LINQ
Andrew Lock - C# Tip: IEnumerable vs ICollection, and why it matters
Davide Bellone - Understanding OverloadResolutionPriority attribute in C# 13
Gérald Barré - What's new in .NET 9: Cryptography improvements
Ali Hamza Ansari - Automatic Upgrade of .NET and External Dependency Versions, Converting Assembly to Package References and More
Dennis Garavsky - .NET 9.0 LINQ Performance Improvements
NDepend Team - Extending MediatR with publishing strategies
Fati Iseni
Cada vez que llega una nueva versión del framework, todos estamos ansiosos por conocer las novedades, especialmente las más espectaculares. Sin embargo, a veces hay pequeñas mejoras que, sin ser revolucionarias, nos pueden resultar útiles en algunos escenarios.
El modificador params permite especificar que un método o función acepta un número variable de argumentos, como en el siguiente ejemplo, donde vemos una función Sum() que puede ser invocada con cualquier número de valores:
// Declaración de la función:
int Sum(params int[] values)
{
return values.Sum();
}
// Ejemplos de uso:
Console.WriteLine(Sum(1)); // Enviamos un único valor -> "1"
Console.WriteLine(Sum(1, 2, 3, 4, 5)); // Enviamos cinco valores -> "15"
Console.WriteLine(Sum()); // No enviamos elementos, se recibirá un array vacío -> "0"
Console.WriteLine(Sum([1, 2, 3])); // Aquí pasamos un array directamente -> "6"
Hasta ahora, el parámetro param sólo podía ser un array, lo que limitaba un poco su uso. Por ejemplo, no podríamos llamar a la función Sum() pasándole directamente un List<int> o un IEnumerable<int> sin convertirlos antes a array porque fallarían en tiempo de compilación, al no tratarse de un int[], que es el tipo del parámetro esperado.
¿Qué ha cambiado?
Aquí tenemos la recopilación de enlaces de la semana. Entre ellos, me han llamado especialmente la atención los datos que muestra Trevor I. Lasn en su artículo sobre el factor edad en el mundo tecnológico, probablemente porque estoy en el 15% del que habla, los desarrolladores que vuelan ya por encima de los 45 tacos 😆
Y aparte, como siempre, un poco de ASP.NET Core, datos, IA, programación web y otros temas que espero que os resulten interesantes 🙂
Por si te lo perdiste...
- Custom middlewares en ASP.NET Core
José M. Aguilar - ¡No uses Replace() para eliminar los guiones de un GUID en .NET!
José M. Aguilar
.NET Core / .NET
- .NET 9 Release Candidate 2 is now available!
.NET Team - Embedding Python into your .NET project with CSnakes
Tony Baloney - Centralize your packages in .NET with NuGet
Steven Giesel - Unleashing .NET 9: Key Performance Boosts and Pitfalls Compared to .NET 8
David McCarter - .NET 8 vs .NET 9: What's the Difference and Should you Migrate?
Cheyenne Sokkappa - Replacing Exceptions-as-flow-control with the result pattern
Andrew Lock - How To Simplify Assertions in Unit and Integration Tests with Verify in .NET
Anton Martyniuk - Domain Events with .NET
Visit profile - Avoiding Repetitive Code With Metalama
Gael Fraiteur - Using Windows Error Reporting in .NET
Kevin Gosse - Have you ever memory-profiled in a unit test?
Dennis Frühauff - Engineering the Scalable Vector Extension in .NET
Kunal Pathak - Typed chat completions with OpenAI and .NET 9
Daniel Cazzulino - Cancellation, Part 6: Linking
Stephen Cleary - Advanced Unit Testing in .NET with xUnit, NSubstitute, and AutoFixture: A Deep Dive into my HangfireDemoApi
Juan Luis Guerrero
Probablemente, todos hemos usado en algún momento el método Guid.NewGuid() de .NET para generar identificadores únicos globales. Y muchos hemos sufrido con el problema que supone su (pseudo) aleatoriedad, principalmente cuando necesitamos ordenarlos... sobre todo si su destino final es acabar siendo el campo clave de una base de datos relacional.
Pero pocos éramos conscientes de que el método Guid.NewGuid() de .NET retorna un GUID versión 4, y que existen otras versiones de UUID (¡hasta 8!) que pueden resultar más beneficiosas en determinados escenarios.
Una semana más, aquí tenéis los enlaces recopilados durante la semana pasada, con mucho protagonismo de los últimos lanzamientos de OpenAI que, si usáis sus APIs o planeáis hacerlo, seguro que os interesarán: la API realtime y el prompt caching.
Por si te lo perdiste...
- El filtro [OutputCache], por fin de vuelta en ASP.NET Core
José M. Aguilar - Gestionar errores 404 (y otros) en ASP.NET Core y MVC
José M. Aguilar
.NET Core / .NET
- What's New in .NET 9: A Developer's Perspective
Vinoth Kumar Sundara Moorthy - How To Test Integrations with APIs Using WireMock in .NET
Anton Martyniuk - How to use IHttpClientFactory and WireMock.NET together using Moq
Davide Bellone - Getting the Running Operating System in C#
Bryan Hogan - Serilog fallback sinks
Nicholas Blumhardt - An Efficient Dictionary for IPAddress Tracking using .NET 9 with AlternateLookup and IAlternateEqualityComparer
Steve Gordon - Effortlessly Upload Files and Data in .NET applications using HttpClient
Hariom Dubey - .NET's ActivityListener sampling API
Nicholas Blumhardt - Visualizing the Serilog 4.1 batch retry algorithm
Nicholas Blumhardt
Como sabemos, una forma habitual de registrar servicios en el contenedor de dependencias de .NET consiste en indicar al framework la implementación de la interfaz o clase abstracta que debe ser utilizada cuando se solicite una instancia de la misma. Por ejemplo, en el siguiente código, que podría pertenecer a la inicialización de una aplicación ASP.NET Core, se registra la implementación FriendDbRepository para la interfaz IFriendRepository con un ámbito scoped o por petición:
builder.Services.AddScoped<IFriendRepository, FriendDbRepository>();
Hecho esto, podríamos solicitar una instancia de IFriendRepository en cualquier parte de nuestra aplicación que admita inyección de dependencias, como los controladores, manejadores Minimal API, otras dependencias, etc. El inyector encargará de proporcionarnos una instancia de FriendDbRepository allá donde la necesitemos:
public class FriendsController: Controller
{
public FriendsController(IFriendRepository friendRepository)
{
// ... Aquí la tenemos!
}
}
O bien, podríamos obtenerla directamente desde la colección de servicios:
public void DoSomething(IServiceProvider services)
{
var repo = services.GetRequiredService<IFriendRepository>();
...
}
Como vemos en ambos casos, la única forma disponible para identificar el servicio que deseamos obtener es utilizar su tipo, o muy habitualmente, la abstracción (interfaz o clase abstracta) a la que está asociado.
Pero eso cambió con la llegada de .NET 8...
Una semana más, comparto la recopilación de enlaces a contenidos que me han parecido interesantes.
De esta tirada, me quedo con "Las interfaces describen qué, las implementaciones describen cómo", un gran título para el artículo de Steve Smith sobre conceptos que todos deberíamos tener claros.
Por si te lo perdiste...
- Cómo crear componentes Blazor usando directamente C# en lugar de la sintaxis Razor
José M. Aguilar - Obtener la última excepción producida en ASP.NET Core
José M. Aguilar
.NET Core / .NET
- (Non-)Nullable Reference Types in C#
Paulo Zemek - Conditional compilation symbols in C#
Bart Wullems - FSZipper in C#
Mark Seemann - Preparing for .NET 9
Mattias Karlsson - A Better Way to Handle Entity Identification in .NET with Strongly Typed IDs
Anton Martyniuk - Boosting Loop Performance in .NET: The Simple Trick of Caching Array Length
David McCarter - Mastering C# 12: New Features and How to Use Them
Cosmic Meta - .NET Terminology
Rockford Lhotka - Interact with Ollama through C#
Bart Wullems - Service Discovery in .NET
Ricardo Peres - Tired of other developers?
Stanislav Nedelchev - Implementing Blocked Floyd-Warshall algorithm for solving all-pairs shortest path problem in C#
Oleg Karasik
Acercándose el lanzamiento de .NET 9 el próximo mes de noviembre, podemos ver ya algunas de las novedades que traerá la nueva versión, con las que podemos jugar desde hace algunos meses instalando las previews que van apareciendo cada mes.
En esta ocasión vamos a ver algunas novedades más interesantes que se han añadido a la biblioteca de serialización JSON oficial, conocida por todos como System.Text.Json:
- Opciones de personalización de la indentación
- Singleton de opciones de serialización y deserialización para la web
- Soporte de anotaciones de anulabilidad
- Comprobación de parámetros obligatorios del constructor
- Descripción de tipos .NET usando JSON Schema
¡Vamos a ello!
Nota: Este artículo está basado en .NET 9 RC1, por lo que algunas de las características descritas podrían cambiar en la versión final.
1. Opciones de personalización de la indentación
Hasta .NET 8, las opciones de personalización relativas al indentado de JSON generado era bastante limitada. De hecho, sólo podíamos decidir si lo queríamos indentar o no usando la propiedad WriteIndented de JsonOptions:
var obj = new
{
Name = "John",
Age = 30,
Address = new { Street = "123 Main St", City = "New York" }
};
var jsonOptions = new JsonSerializerOptions()
{
WriteIndented = true, // Queremos indentar el JSON
};
Console.WriteLine(JsonSerializer.Serialize(obj, jsonOptions));
El resultado será siempre un JSON indentado a dos espacios como el siguiente:
{
"Name": "John",
"Age": 30,
"Address": {
"Street": "123 Main St",
"City": "New York"
}
}
En .NET 9 disponemos de dos nuevas propiedades para personalizar la indentación del JSON generado. La propiedad IndentCharacter permite especificar el carácter a utilizar (espacio o tabulador, exclusivamente), y mediante IndentSize podemos indicar el número de caracteres a utilizar en cada nivel de indentación.
var jsonOptions = new JsonSerializerOptions()
{
WriteIndented = true,
IndentCharacter = '\t',
IndentSize = 2
};
Console.WriteLine(JsonSerializer.Serialize(obj, jsonOptions));
En este caso, el resultado será así (2 tabuladores por nivel de indentación):
{
"Name": "John",
"Age": 30,
"Address": {
"Street": "123 Main St",
"City": "New York"
}
}
2. Singleton de opciones de serialización y deserialización para la web
ASP.NET Core utiliza una configuración por defecto para serializar y deserializar objetos JSON, que ahora está disponible de forma pública en la propiedad JsonSerializerOptions.Web.
El objeto retornado es un singleton JsonSerializerOptions de sólo lectura, que estará disponible en cualquier punto de la aplicación.
Por defecto, este objeto está configurado de la siguiente manera:
PropertyNameCaseInsensitiveestá establecido atrue, por lo que la deserialización de propiedades es insensible a mayúsculas y minúsculas.JsonPropertyNamingPolicytiene el valorJsonNamingPolicy.CamelCase, así que las propiedades se serializan en formato camelCase, el habitual en JavaScript y JSON.NumberHandlingesJsonNumberHandling.AllowReadingFromString, así que será posible deserializar números que vengan especificados como texto.
Un ejemplo de utilización de este objeto sería el siguiente:
var obj = new
{
Name = "John",
Age = 30,
Address = new { Street = "123 Main St", City = "New York" }
};
Console.WriteLine(JsonSerializer.Serialize(obj, JsonSerializerOptions.Web));
// Resultado:
// {"name":"John","age":30,"address":{"street":"123 Main St","city":"New York"}}
Dado que el objeto es de sólo lectura, no podemos modificar sus propiedades. Si necesitásemos algún tipo de cambio en la configuración, podríamos crear una configuración nueva partiendo de él, e introducir las modificaciones deseadas, por ejemplo:
var jsonOptions = new JsonSerializerOptions(JsonSerializerOptions.Web)
{
WriteIndented = true,
IndentCharacter = '\t',
IndentSize = 2
};
3. Soporte de anotaciones de anulabilidad
En .NET 8 y versiones anteriores, System.Text.Json no respetaba las anotaciones de anulabilidad de C# en las propiedades de los tipos de referencia. Por ejemplo, si tenemos una propiedad de tipo referencia que no puede ser nula como en el siguiente caso, podemos ver que el siguiente código deserializará sobre ella un valor nulo sin problema:
var myFriend = JsonSerializer.Deserialize<Friend>("""{ "Name": null }""");
Console.WriteLine(myFriend.Name ?? "Unknown"); // Muestra "Unknown"
// Friend tiene un campo "Name" que no puede ser nulo
public record Friend (string Name);
A partir de .NET 9, podemos indicar opcionalmente a System.Text.Json que respete la anulabilidad de propiedades, es decir, si una propiedad no es anulable, al deserializarla no podremos establecerla al valor nulo.
Esto podemos conseguirlo simplemente estableciendo a true la propiedad RespectNullableAnnotations de las opciones de deserialización:
var opt = new JsonSerializerOptions() { RespectNullableAnnotations = true };
var myFriend = JsonSerializer.Deserialize<Friend>("""{ "Name": null }""", opt);
Console.WriteLine(myFriend.Name ?? "Unknown"); // Lanza una excepción
Según la documentación, otra posibilidad es hacerlo de forma global para todo el proyecto, añadiendo la siguiente configuración en el archivo .csproj:
<ItemGroup>
<RuntimeHostConfigurationOption
Include="System.Text.Json.JsonSerializerOptions.RespectNullableAnnotations"
Value="true" />
</ItemGroup>
Supongo que, debido a que aún estamos jugando con versiones preview del compilador, esta última opción no conseguí que me funcionara.
Otra cosa que he visto curiosa es que el siguiente código, a mi entender, debería lanzar una excepción, pero no lo hace:
var opt = new JsonSerializerOptions() { RespectNullableAnnotations = true };
var myFriend = JsonSerializer.Deserialize<Friend>("{ }", opt);
Console.WriteLine(myFriend.Name ?? "Unknown"); // Muestra "Unknown"
En principio, si la propiedad Name hemos dicho que no era anulable, ¿no debería lanzar una excepción al deserializar un objeto que no especifica su valor? Pues no, y parece ser que se trata de un comportamiento esperado; hay un interesante hilo al respecto en GitHub discutiendo el por qué de esta decisión, aunque en el siguiente apartado veremos que existe en algunos casos existe una forma alternativa de evitar esta situación.
Por último, la propiedad RespectNullableAnnotations también afecta a la serialización, de forma que si una propiedad no anulable tiene un valor nulo al ser serializada, se lanzará una excepción:
var opt = new JsonSerializerOptions() { RespectNullableAnnotations = true };
var myFriend = new Friend(null);
Console.WriteLine(JsonSerializer.Serialize(myFriend, opt)); // Lanza una excepción
4. Comprobación de parámetros obligatorios del constructor
En .NET 8 y anteriores, los parámetros del constructor del tipo a deserializar eran tratados como siempre como opcionales. Por esta razón, el código siguiente no provoca errores:
var myFriend = JsonSerializer.Deserialize<Friend>("""{ }""");
Console.WriteLine(myFriend.Name ?? "Unknown"); // Muestra "Unknown"
public record Friend(string Name);
En .NET 9, es posible indicar al deserializador que queremos respetar los parámetros requeridos del constructor, de forma que si no pueden ser satisfechos se lanzará una excepción. Esto se consigue con el nuevo flag RespectRequiredConstructorParameters en las opciones de deserialización:
var opt = new JsonSerializerOptions() { RespectRequiredConstructorParameters = true };
var myFriend = JsonSerializer.Deserialize<Friend>("""{ }""", opt);
Console.WriteLine(myFriend.Name ?? "Unknown"); // Lanza una excepción
La excepción, de tipo JsonException es bastante clara en su texto de descripción: 'JSON deserialization for type 'Friend' was missing required properties including: 'Name'.'.
Como en el caso anterior, este comportamiento puede ser también configurado de forma global para todo el proyecto, añadiendo la siguiente configuración en el archivo .csproj:
<ItemGroup>
<RuntimeHostConfigurationOption
Include="System.Text.Json.JsonSerializerOptions.RespectRequiredConstructorParameters"
Value="true" />
</ItemGroup>
Y como en el caso anterior, tampoco he conseguido que me funcione de esta forma 😆 Esperemos que las siguientes preview o la versión final lo solucionen.
5. Descripción de tipos .NET usando JSON Schema
La nueva clase estática JsonSchemaExporter expone el método GetJsonSchemaAsNode(), que permite obtener el esquema JSON de un tipo .NET en forma de objeto JsonNode.
Su uso es muy sencillo, simplemente pasamos las opciones a utilizar para serializar el esquema, y el tipo del que queremos obtenerlo. Observad el siguiente ejemplo:
var schema = JsonSchemaExporter.GetJsonSchemaAsNode(
JsonSerializerOptions.Default,
typeof(Friend)
);
Console.WriteLine(schema);
public record Friend(string Name, string? nickName, int Age = 20);
El resultado que obtendremos es una descripción del tipo, siguiendo el estándar JSON Schema, que en este caso sería algo así:
{
"type": [
"object",
"null"
],
"properties": {
"Name": {
"type": "string"
},
"nickName": {
"type": [
"string",
"null"
]
},
"Age": {
"type": "integer",
"default": 20
}
},
"required": [
"Name",
"nickName"
]
}
Conclusión
En este artículo hemos visto algunas de las novedades que traerá la nueva versión de .NET 9 en la biblioteca de serialización JSON oficial, System.Text.Json. Aunque no son cambios revolucionarios, sí que son mejoras que facilitarán la vida a los desarrolladores que trabajamos con JSON en nuestras aplicaciones.
¡Espero que os haya resultado interesante!
Vamos con la recopilación de enlaces de la tercera semana de septiembre, donde, como es habitual, podemos ver un poco de todo: algunos lanzamientos, características de C#, uso de herramientas de telemetría y monitorización, rendimiento en ASP.NET Core, frontend, y más.
Como reflexión, es curioso ver que la IA está presente en cada vez más áreas del desarrollo. Y aparte, me quedo con lo poco que se suelen usar los operadores implícitos de C#, cuando realmente pueden hacer nuestro código más limpio...
Por si te lo perdiste...
- Atributos genéricos en C# 11
José M. Aguilar - Cacheo de porciones de vistas en ASP.NET Core MVC
José M. Aguilar
.NET Core / .NET
- Join the .NET Smart Components ecosystem
Daniel Roth - TUnit, new testing framework for .NET 8 and up.
Tom Longhurst - Disabling Recording of an Activity (span) in .NET OpenTelemetry Instrumentation
Steve Gordon - How to run .NET apps natively on Arm64 devices
Mark Downie - Understanding the behavior of the XAML Designer with abstract base classes
Peter Spada - A Modern Way to Create Value Objects to Solve Primitive Obsession in .NET
Anton Martyniuk - Using Polly For Retries
Scott Galloway - Managing TaskCancellationTokens in a central service in ASP.NET
Steven Giesel - C# 11.0 new features: ref fields and the scoped keyword
Ian Griffins - Use the implicit operator to reduce noise in your code
Josef Ottosson
Una pregunta que me hacen con cierta frecuencia los alumnos de mi curso de ASP.NET Core en CampusMVP es que por qué, al ejecutar una aplicación de este tipo, Visual Studio les muestra un mensaje como el siguiente, no se lanza el navegador y no pueden acceder a la aplicación:
Generalmente la respuesta es bastante sencilla: Visual Studio nos está informando de que el servidor web no ha sido lanzado al ejecutar la aplicación.
Tras unas semanas de merecido descanso, volvemos a la carga con el blog, inaugurando lo que, más o menos, debería ser su temporada número 18. Como de costumbre, intentaremos seguir la serie semanal de enlaces de interés y escribiendo sobre trucos, novedades y características de C#, .NET, ASP.NET Core, Blazor, JavaScript, o cualquier cosa que se ponga por delante y que considere que puede ser de utilidad para la comunidad.
Y para empezar con buen pie, lo haremos con la recopilación número 576 de enlaces que, como de costumbre, espero que os resulten interesantes. Especialmente destacable, además del lanzamiento de .NET 9 RC1, es el esperado post "Performance improvements in .NET 9" del gran Stephen Toub, todo un clásico cuando se va acercando una nueva versión del framework. Sencillamente imprescindible si queréis estar a la última.
Por si te lo perdiste...
- Creación de enlaces con tag helpers de Core MVC
José M. Aguilar - Restricciones de ruta personalizadas parametrizables en ASP.NET Core
José M. Aguilar
.NET Core / .NET
- Analizando tu código sin morir en el intento
Adrián Díaz Cervera - .NET 9 Release Candidate 1 is now available!
.NET Team - Performance Improvements in .NET 9
Stephen Toub - The Best Way To Validate Objects in .NET in 2024
Anton Martyniuk - Back to Basics: Await a Task with a Timeout
Rick Strahl - Working with tar files in .NET 8
Andrew Lock - Why is F# code so robust and reliable?
Akunyili Chukwuma - What are partial classes in C# and why do we use them?
David Grace - Optimizing Hash Code Generation in .NET: A Performance Comparison
David McCarter - Thread-Safe Singleton in C#: A Guide to Double-Checked Locking and Lazy<T> Approaches
Antonio Ripa - Intersperse Values for Enumerable Collections
Khalid Abuhakmeh - Alternate Lookup for Dictionary and HashSet in .NET 9
NDepend Team - Autofixture and IOptions<T> - A Winning Combination
Adam Storr
Hago una ligera interrupción de mis vacaciones blogueras para compartir con todos vosotros que, por decimocuarto año consecutivo, he sido reconocido por Microsoft como Most Valuable Professional (MVP) en la categoría .NET ¡¡Hurra!! 😀
Aunque ya debería estar acostumbrado, siempre es un honor y un privilegio recibir este galardón que, de alguna forma, reconoce mis aportaciones a la comunidad de desarrolladores, esa comunidad con la que sigo estando en deuda por lo que he recibido de ella durante tanto tiempo.
Muchas gracias al equipo de Microsoft que hace esto posible, con nuestra querida Cristina González a la cabeza, por la dedicación y esfuerzo que ponen en este programa. Muchas gracias también a todos los compañeros MVPs que hacen que esta comunidad sea tan especial.
Y, por supuesto, agradeceros a todos vosotros, queridos amigos y amigas, por seguir ahí, porque vuestras visitas, lecturas y comentarios son los que me animan a seguir compartiendo experiencias y conocimientos en este pequeño rinconcito de la web.
¡Nos vemos a la vuelta!
Publicado en Variable not found.
Foto: Atardecer en la playa en Costa Ballena, por Eugenio Sánchez. Original: foro.ojodigital.com
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Inyección de dependencias en ASP.NET Core(actualizado)
José M. Aguilar - Añadir al routing de Blazor páginas definidas en otros proyectos o ensamblados
José M. Aguilar
.NET Core / .NET
- Flexible PDF Reporting in .NET Using Razor Views
Milan Jovanović - MemoryCache in C#: A Practical Guide
Metalama Team - Local Functions vs Lambda Expressions in C#
Bozo Spoljaric - Creating hashes in .NET
Damien Bowden - How to find a client's geolocation in .NET with IP lookup
David Grace - Publish a console app as a single executable
Bart Wullems - How to output a SARIF file from a .NET project
Gérald Barré - An immutable priority collection
Mark Seemann - Exploring the generated code: the spread element
Andrew Lock - Readonly, Immutable, and Frozen Collections in .NET
NDepend Team - How to Read appsettings.json in a .NET Console Application
Matheus Dasuke - Scan HTML faster with SIMD instructions: .NET/C# Edition
Daniel Lemire
Cuando en un bucle for necesitamos más de una variable de control, lo habitual es inicializarlas fuera del bucle y luego usarlas en su interior, por ejemplo, como en el siguiente código:
int j = 0;
for (int i = 0; i < 10 && j < 100; i++)
{
Console.WriteLine($"i = {i}, j = {j}");
j+= 10;
}
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- Miembros de inicialización obligatoria en C#11 (required members)
José M. Aguilar - Tag helpers en ASP.NET Core MVC: Introducción
José M. Aguilar
.NET Core / .NET
- Primary constructors
Mark Downie - Proxy Design Pattern in C#
Ahsan Ullah - How to Generate Large Datasets in .NET for Excel With OpenXML
Artem Rudiakov - Exploring the generated code: T[], Span<T>, and Immutable collections
Andrew Lock - When to create a new .csproj?
NDepend Team - ReadOnlySet<T> in .NET 9
Steven Giesel - C# Tip: Path.Combine and Path.Join are similar but way different.
Davide Bellone
Blazor ha venido en ASP.NET Core 8 cargadito de novedades, aunque probablemente la más destacable sea la introducción de las Blazor Web Apps como modelo de proyecto que unifica los distintos modos de renderizado de componentes. Aunque se trata de un cambio positivo, la realidad es que ha complicado algunas cosas que antes, con unos modelos de proyecto más sencillos, eran más fáciles de implementar.
Un ejemplo claro lo tenemos en las páginas de error 404 (not found): con este nuevo modelo unificado no hay una fórmula trivial o integrada de serie en el framework para implementar esta funcionalidad, tan habitual en nuestras aplicaciones.
En este post vamos a ver un posible enfoque para conseguir que si un usuario introduce una ruta inexistente en el navegador o bien pulsa un enlace interno que no exista, podamos mostrarle una página de error 404 totalmente personalizada, implementada como componente Blazor, e integrada en nuestra Blazor Web App.
Ahí van los enlaces recopilados durante la semana pasada. Espero que os resulten interesantes. :-)
Por si te lo perdiste...
- ¡No uses ToLower() o ToUpper() para comparar cadenas en C#!
José M. Aguilar - El archivo _ViewImports en ASP.NET Core MVC
José M. Aguilar
.NET Core / .NET
- Refactor your code with default lambda parameters
David Pine - Cancellation Tokens in C#
Rasheed K Mozaffar - When does the try, catch and finally blocks run in C#?
David Grace - Collection Performance: Introducing FrozenSet in .NET 8: Benefits and Benchmark PerformanceCollection Performance
David McCarter - Privacy and security improvements in .NET modernization tooling
Mike Rousos - How to Cast an Int to an Enum in C#
Chris Pietschmann - Exploring the generated code: List<T> and fallback cases
Andrew Lock - How to Ignore a Property in AutoMapper
Żaneta Borowska - C#: Read Text and JSON File Contents into Variable in Memory
Chris Pietschmann - How to Use FakeLogger to Test Logging Code in .NET
Osman Sokuoglu - How to Use C# to Properly Follow OAuth Authentication Flows
Peter Smulovics - C# 13 params collections
NDepend Team - What Does the null! Statement Do?
Januarius Njoku - Announcing Third Party API and Package Map Support for .NET Upgrade Assistant
Marco Goertz - The Best Way To Map Objects in .Net in 2024
Anton Martyniuk
