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.