El lenguaje C# no para de crecer. En estos momentos nos encontramos en la versión número 10 de la mano de .Net 6. Microsoft no para de mejorar el lenguaje escuchando, en muchos casos, a la comunidad. Esto hace que siempre tengamos muchas mejoras en cada versión dificultando no poder llegar a aprenderlas o implementarlas y quedan olvidadas en el tiempo.

Por esta razón, quería traerles las cosas más importantes que deberíamos tener presentes con la versión actual.

Pattern matching

Esta funcionalidad que apareció en C# 7. Básicamente, nos ayuda a extraer una expresión para determinar si tiene alguna característica particular. En esta versión tenemos una gran cantidad, veamos los más interesantes.

Null Checks

Algo que validamos todo el tiempo es que un valor no sea nulo, todos odiamos el error Null Reference. Veamos como un ejemplo para probar el tipo de variable y asignarlo a una nueva dependiendo de ese tipo.

int? valor = 12;
if (valor is int number)
{
    Console.WriteLine($"The nullable int 'valor' has the value {number}");
}
else
{
    Console.WriteLine("The nullable int 'valor' doesn't hold a value");
}

Relationals Patterns

Podemos utilizar para comparar valores constantes un patrón relacional, vemos el ejemplo siguiente de código para validar temperaturas.

string WaterState(int tempInFahrenheit) =>
    tempInFahrenheit switch
    {
        (> 32) and (< 212) => "liquid",
        < 32 => "solid",
        > 212 => "gas",
        32 => "solid/liquid transition",
        212 => "liquid / gas transition",
    }

Test Type

Probar una variable para verificar si es de un tipo determinado. En el ejemplo podemos ver que se comprueba si una variable no es null. Luego, si es un tipo list, nos permitirá usar el Count, ni es nulo ni una excepción y por último realizar varias tareas, todo dependiendo si el tipo es correcto.

public static T MidPoint<T>(IEnumerable<T> sequence)
{
    if (sequence is IList<T> list)
    {
        return list[list.Count / 2];
    }
    else if (sequence is null)
    {
        throw new ArgumentNullException(nameof(sequence), "Sequence can't be null.");
    }
    else
    {
        int halfLength = sequence.Count() / 2 - 1;
        if (halfLength < 0) halfLength = 0;
        return sequence.Skip(halfLength).First();
    }
}

Top-level statements

Muchas de las características nuevas están relacionadas con reducir el código. Este tipo de instrucciones pueden reemplazar mucha cantidad de código veamos un ejemplo de una consola.

Consola 

using System;
namespace ConsoleApp1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

Resumiendo (.Net 6)

using System;
Console.WriteLine("Hello World!");

Records

Record es un tipo que nos proporciona una forma de encapsular datos. Nos permite crear tipos de registros inmutables. hoy, sí tenemos que crear un dto o un modelo, el mejor camino es usar records ya que son más eficientes que una clase. Es muy similar a crear una clase, la magia ocurre por detras.

class SalesOrder
{
    public int OrderId { get; init; }
    public string ProductName { get; init; }
    public int Quantity { get; init; }
    static void Main(string[] args)
    {
        SalesOrder order = new SalesOrder { OrderId = 1, ProductName = "Mobile", Quantity = 2 };
        //now we need to change "ProductName"
        SalesOrder newOrder = new SalesOrder { OrderId = order.OrderId, ProductName = "Laptop", Quantity = order.Quantity };
    }
}

Usando records

public record SalesOrder
{
    public int OrderId { get; init; }
    public string ProductName { get; init; }
    public int Quantity { get; init; }
    static void Main(string[] args)
    {
        SalesOrder order = new SalesOrder { OrderId = 1, ProductName = "Mobile", Quantity = 2 };
        //using with expression
        SalesOrder newOrder = order with { ProductName = "Laptop" };
    }
}

Init-only setters

Se ha simplificado la sentencia de init. Podemos inicializar los datos inmutables durante la creación del objeto, esto nos permite crear propiedades inmutables.

class Product
{
    public int ProductId { get; }
    public string ProductName { get; set; }
    public Product(int productId)
    {
        ProductId merId = productId;
    }
    static void Main(string[] args)
    {
        var product= new Product(2345)
        {
            ProductName = "Computer"
        };
        //no es posible establecer el valor porque es inmutable
        product.ProductId  = 3232;
    }
}

modificando el código

class Product
{
    public int ProductId { get; init; }
    public string ProductName { get; set; }
    static void Main(string[] args)
    {
        var product= new Product()
        {
            ProductId = 2345,
            ProductName = "Computer"
        };
        //no es posible establecer el valor porque es inmutable
        customers.CustomerId = 3232;
    }
}

Conclusiones

Estas son algunas de las características que debemos tener presentes que día a día se están utilizando con más frecuencia. Podemos consultar la documentación de C# para ver todas las nuevas características que tenemos. Espero que hayan disfrutado el artículo.