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...