Novedades de C# 9.0

Pues eso… tal como te dije hace unos días, ya ha llegado el momento de explicarte algunas de las novedades de C# 9.0; concretamente aquí te voy explicar de forma concisa (sin enrollarme mucho) en qué consisten tres de las novedades que trae la versión 9.0 de C#, la que se incluye en .NET 5.0 que en este mes de noviembre estará en modo release o, dicho de otro modo, en versión final.

NOTA:
En realidad hoy día 10 de noviembre lo han publicado, mientras escribía este artículo se hacía la presentación oficial de .NET 5.0 en el .NET Conf 2020 (que puedes ver la grabación usando el enlace).

Estas novedades que te voy a explicar aquí están basadas en la documentación de .NET, concretamente en: Novedades de C# 9.0.
Y las tres novedades que he elegido son las siguientes:
1- Instrucciones de nivel superior (Top-level statements)
2- Registros (Records)
3- Establecedores de solo inicialización (Init only setters)

NOTA:
No me voy a explayar (alargar demasiado) en las explicaciones, si quieres detalles, por favor mira el enlace que te he puesto antes y en la documentación te lo explican con gran lujo de detalles.

Para usar el compilador de C# 9.0 necesitarás tener instalado .NET 5.0 y el código ejecutarlo con Visual Studio 2019 Preview o usando dotnet desde la línea de comandos o con Visual Studio Code.

Instrucciones de nivel superior (top-level statements)

Esta novedad es solo aplicable a un fichero en cada proyecto de C# y viene a ser una forma más simple de escribir el punto de entrada de una aplicación que normalmente se define con el método estático Main. De hecho, si se utiliza esta forma de escribir el código no podrá existir otro punto de entrada diferente, es decir, no podrá haber otro método estático Main que indique por dónde empezar a ejecutar el código.

En cualquier programa de C# nos encontraremos con un código parecido a este (por ejemplo el clásico Hola Mundo:

using System;

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

Pero ahora con C# 9.0 lo podemos simplificar de esta forma:

using System;

Console.WriteLine("Hello World!");

Es decir, nos quedamos con el código realmente operativo. En este caso la importación de System para poder acceder al método WriteLine de la clase Console.

Como te comenté antes, esta forma de escribir el código solo se puede hacer en un fichero del proyecto y equivale al método de entrada de dicho proyecto.

Si ese método debe manipular los argumentos de la línea de comando, estos se pueden seguir gestionando con args (aunque no estén indicados en ningún sitio).

Por ejemplo, supongamos que queremos tomar el primer argumento como el nombre al que saludar, lo haríamos de esta forma:

using System;

Console.WriteLine("¡Hola {0}!", args[0]);

De la misma forma, si nuestro método Main (aunque no haya aparentemente ninguno) tiene que devolver un valor, por ejemplo que devuelva 1 si no se ha indicado nada en la línea de comandos o lo indicado está vacío, lo haríamos de la siguiente forma:

using System;

if (args.Length == 0 || string.IsNullOrEmpty(args[0]) )
    return 1;

Console.WriteLine("¡Hola {0}!", args[0]);

return 0;

Si ejecutas el código anterior sin indicar nada (ningún argumento) no hará (aparentemente) nada, pero en realidad si hace, ya que devuelve 1 como resultado de la ejecución. Si se indica algo mostrará el mensaje de saludo y devolverá cero.

Para hacerlo más evidente, podemos cambiar el if de la siguiente forma:

using System;

if (args.Length == 0 || string.IsNullOrEmpty(args[0]))
{
    Console.WriteLine("Debes escribir un nombre.");
    return 1;
}

Console.WriteLine("¡Hola {0}!", args[0]);

return 0;

Ahora estará más claro que no hemos escrito nada como argumento al ejecutar el programa.

NOTA:
Si has elegido usar dotnet puedes hacer las pruebas de la siguientes formas:
(se supone que estás usando la terminal de Visual Studio Code o el símbolo del sistema con el directorio activo donde esté el código.

Si indicas un argumento, será así:
dotnet run Guille
y el resultado será:
¡Hola Guille!

Si no indicas argumentos escribe esto:
dotnet run
y el resultado será:
Debes escribir un nombre.

En la figura 1 puedes ver la salida de las dos formas de usarlo (con o sin argumento).

 

Registros (Records)

Para escribir el código de la segunda novedad de C# 9.0 vamos a crear un nuevo proyecto, si quieres hacerlo con dotnet desde la línea de comandos, sitúate en la carpeta donde dotnet creará una carpeta con el código necesario para este ejemplo el cual se llamará novedadescs9_02 y escribe lo siguiente:

dotnet new console -o novedadescs9_02

Cambia al directorio recién creado con cd novedadescs9_02 y edita el fichero Program.cs para que tenga el código que te mostraré a continuación, aunque antes un poco de explicación sobre de qué va esto de los registros o records.

Los tipos de registro (record types) es un tipo por referencia que son inmutables de forma predeterminada. Inmutable significa que una vez creados no se pueden modificar.

Hasta ahora los tipos por referencia (clases y tipos anónimos) no contenían los datos que manipulaban si no una referencia a esos datos, mientras que los tipos por valor (entre ellos las estructuras y tuplas) contienen los valores, es decir, si pasamos un tipo por valor a un método se pasa una copia de los datos, a diferencia de los tipos por referencia que pasan una referencia al objeto en memoria que contiene los valores.
Y esto es principalmente lo que hacen los tipos de registro cuando se pasan a un método, no se pasa la referencia, si no una copia de los datos.

De hecho este es uno de los puntos importantes de los tipos record, que al ser inmutables se pueden comparar de la misma forma que comparamos, por ejemplo un tipo entero, y devolverá un valor de igualdad si todos los campos/propiedades que contiene son iguales. Algo que con las clases no ocurre.

Veamos una declaración de un tipo record de la forma más simple (ahora veremos cómo definirlo de una forma parecida a una clase.

NOTA:
Para simplificar voy a usar el código tal y como te he explicado en el primer punto de este artículo como instrucciones de nivel superior (top-level statements).

public record Persona(string Nombre, int Edad);

Esta sería la forma simplificada de definir un registro.
En este caso usamos la palabra clave record y en este caso define un tipo de registro con dos propiedades: Nombre de tipo cadena y Edad de tipo entero.

Para usarla lo haremos de la misma forma que con otros tipos:

var persona1 = new Persona("Guillermo", 63);
Console.WriteLine(persona1);

Fíjate que al mostrar el contenido de la variable persona1 se muestra de una forma ya predefinida, pero como siempre, al forma de actuar de ToString (que es el que se encarga de mostrarlo de esa forma), lo puedes definir a tu antojo.
En ese ejemplo la salida será la siguiente:

Persona { Nombre = Guillermo, Edad = 63 }

Si queremos definir un método ToString personalizado lo haremos de la forma tradicional (ahora tenemos que usar llaves para definir el método):

public record Persona2(string Nombre, int Edad)
{
    public override string ToString()
    {
        return $"{Nombre} nació en {DateTime.Now.Year - Edad}";
    }
}

Por supuesto también podemos usar la herencia con los tipos record, imagina que el tipo Persona2 lo quieres derivar de Persona y añadir la definición de ToString, simplemente lo haríamos así:

public record Persona2(string Nombre, int Edad) : Persona (Nombre, Edad)
{
    public override string ToString()
    {
        return $"{Nombre} nació en {DateTime.Now.Year - Edad}";
    }
}

Aunque aquí no ganamos mucho, pero al menos definimos Persona2 a partir del tipo Persona.

Para ver una clase derivada que añada alguna funcionalidad extra, por ejemplo que tenga otra propiedad más podemos definir el tipo Personaje a partir del tipo Persona, en este caso, el tipo Personaje define una propiedad de tipo entero llamada Desde (además de las dos propiedades que expone el tipo Persona).

public record Personaje(string Nombre, int Edad, int Desde) : Persona(Nombre, Edad)
{
    public override string ToString()
    {
        return $"{Nombre} nació en {DateTime.Now.Year - Edad} y está activo desde {Desde}.";
    }
}

Aquí también definimos el método personalizado ToString, pero si no queremos definirlo, simplemente haríamos lo siguiente:

public record Personaje(string Nombre, int Edad, int Desde) 
                        : Persona(Nombre, Edad);

Al mostrar el contenido del personaje1 el resultado en este caso sería (obviamente) el predeterminado del método ToString.

En la figura 2 tienes la salida del código con la definición propia del método ToString y en la figura 3 la salida sin definir un método ToString para el tipo de registro Personaje.

 

Así que, ya es cosa tuya cómo quieres que se comporte el método ToString.

Por supuesto, puedes definir otros métodos que necesites. Y ya sabes cómo 😉

¿Qué significa que los tipos record son inmutables?

Como te comenté antes, las propiedades definidas en un tipo de registro no se pueden cambiar, son inmutables (como las cadenas de .NET), por tanto si queremos cambiar el valor de una propiedad de un tipo ya en memoria, simplemente NO PODEMOS HACERLO. De hecho, de hacerlo lo que conseguiríamos es crear un nuevo registro con los nuevos valores. Pero vayamos por pasos.
Si tienes la definición de Persona que hemos visto anteriormente y decides cambiar la edad de la persona1 simplemente no podrás, ya que te indicará que Edad es de solo lectura.

Escribe lo siguiente (pongo el código completo para que te resulte más fácil hacer la prueba):

using System;

var persona1 = new Persona("Guillermo", 63);
Console.WriteLine(persona1);
persona1.Edad = 64;
Console.WriteLine(persona1);

public record Persona(string Nombre, int Edad);

Si intentas ejecutar esto desde la línea de comandos con dotnet te mostrará el siguiente error (ver la figura 4):

Si ese código lo escribes en Visual Studio 2019 Preview, tal como puedes ver en la figura 5, te mostrará la asignación (lo que te muestro en rojo en el código anterior) como un error que indica que:

Error CS8852: Init-only property or indexer 'Persona.Edad' can only be assigned in an object initializer, or on 'this' or 'base' in an instance constructor or an 'init' accessor.

Ese mensaje nos lo aclarará la siguiente y última sección de este artículo sobre las novedades de C# 9.0. Pero eso dentro de un momento.

var persona2 = persona1 with { Edad = 64 };

Console.WriteLine("La persona2: {0}.",persona2);

Aquí lo que hemos hecho es crear una copia de persona1 con un nuevo valor en la edad, pero realmente son dos objetos en memoria diferentes: Uno con la edad de 63 y el otro con la edad de 64, es decir: ¡hemos clonado al guille con un año más! (de seguir con otro ejemplo más, me jubilaré pronto jejeje).

Fíjate que no hemos usado el tipo Persona para crear el nuevo objeto, simplemente lo hemos creado a partir del que ya estaba definido en persona1, pero con algunos datos diferentes, en este ejemplo simplemente hemos cambiado el valor de Edad.

Ahora veremos lo que te comentaba al principio de la forma de comparar objetos creados a partir de tipos de registro.

Veamos el siguiente código en el que definimos dos objetos del tipo Persona, en los que los hemos inicializado con los mismos datos y después asignamos a la variable iguales el resultado de comparar con == ambos objetos.
como veremos al ejecutar el código es que ambos son iguales, ¡aunque en realidad sean dos objetos diferentes!

var persona1 = new Persona("Guillermo", 63);
Console.WriteLine("La persona1: {0}.", persona1);

var persona2 = new Persona("Guillermo", 63);
Console.WriteLine("La persona2: {0}.", persona2);

var iguales = persona1 == persona2;
Console.WriteLine("persona1 == persona2 es {0}", iguales);


public record Persona(string Nombre, int Edad);

El resultado de ejecutar ese código será el siguiente:

La persona1: Persona { Nombre = Guillermo, Edad = 63 }.
La persona2: Persona { Nombre = Guillermo, Edad = 63 }.
persona1 == persona2 es True

Esa comparación de igualdad la podemos escribir de la siguiente forma:

var iguales = persona1.Equals(persona2);
Console.WriteLine("persona1.Equals(persona2) es {0}", iguales);

El resultado será el mismo que usando el operador de igualdad.

Y para finalizar este apartado de los tipos de registro veamos qué ocurre si tenemos el siguiente código:

var persona2 = persona1 with { Edad = 64 };
Console.WriteLine("La persona2: {0}.", persona2);

var iguales = persona1.Equals(persona2);
Console.WriteLine("persona1.Equals(persona2) es {0}", iguales);

¿Cuál crees que será el valor de iguales?

La respuesta: tendrás que ejecutar el código para comprobarlo 😉

 

Deconstruir tipos de registro

Una cosa interesante con los tipos de registro (record) es lo que se conoce como de-constructor (Deconstruct) (mira la documentación para una explicación detallada) ya que aquí solo te pondré un ejemplo para que sepas que se puede hacer algo como esto:

var persona = new Persona("Guillermo", 63);
Console.WriteLine("La persona: {0}.", persona);

var (n, e) = persona;
Console.WriteLine($"{n} {e}");


public record Persona(string Nombre, int Edad);

Es decir, podemos asignar a una tupla el contenido de un registro, en este ejemplo (tal como puedes comprobar al ejecutar el código) es que se asignan los valores del Nombre y la Edad a la tupla.

 

 

Establecedores de solo inicialización (Init only setters)

Tal como vimos en el penúltimo ejemplo, o mejor dicho en el mensaje de error del penúltimo ejemplo (al que asignamos un valor a la propiedad Edad de un tipo de registro), el mensaje de error indica que las propiedades de solo inicialización solo se pueden asignar en un inicializador de objeto.
Es decir, la propiedad Edad es de solo lectura, pero en este caso, el error nos indica que la propiedad de solo inicialización (init-only property) solo se puede usar en un inicializador de objetos. Y aquí es donde entra esta tercera novedad de C# 9.0 que te quiero comentar, pero veamos primero un código de ejemplo de cómo usar esta nueva instrucción: init.

class Persona
{ 
    public string Nombre { get; init; }
    public int Edad { get; init; }
}

Como ves en el código anterior, en la definición de las propiedades de la clase Persona están los modificadores get e init. Get es, como bien supondrás, la parte que devuelve el valor de la propiedad (lo que hasta ahora hemos tenido) y en este caso init sustituye al modificador set de la propiedad; pero en este caso concreto le indicamos que esa asignación se hará solo y exclusivamente al iniciar una instancia de la clase Persona.

Una forma de definir un objeto persona1 a partir de la clase Persona sería la siguiente:

var persona1 = new Persona { Nombre = "Guillermo", Edad = 63 };

Aquí estamos usando una clase en lugar de un tipo de registro. Por eso esa forma de crear el nuevo objeto. Lo he hecho así, para que no te olvides de cómo crear nuevos objetos a partir de una clase 😉

Como ves el funcionamiento es parecido a lo que hemos visto en la sección anterior, pero el definir una clase es porque los tipos de registro de forma predeterminada tienen el inicializador definido en las propiedades.

Pero el que los tipos de registro sean inmutables no quiere decir que no podamos definir propiedades de lectura/escritura, de hecho podemos hacer algo como esto:

record Persona
{
    public string Nombre { get; set; }
    public int Edad { get; init; }
}

Con el código anterior creamos un record que permite cambiar el valor de la propiedad Nombre, por tanto podemos hacer algo como lo siguiente sin que nos de error:

var persona1 = new Persona { Nombre = "Guillermo", Edad = 63 };
Console.WriteLine(persona1);

persona1.Nombre = "Guille";
Console.WriteLine(persona1);

Y podemos hacerlo porque la propiedad Nombre ya no está definida como solo de inicialización.

Pero aún así, si definimos otro objeto del tipo (record) Persona con los mismos datos, la comparación de igualdad seguirá funcionando como vimos anteriormente.

var persona1 = new Persona { Nombre = "Guillermo", Edad = 63 };
persona1.Nombre = "Guille";

Console.WriteLine(persona1);

var persona2 = new Persona { Nombre = "Guille", Edad = 63 };

var iguales = persona1 == persona2;
Console.WriteLine("persona1 == persona2 es {0}", iguales);

En este caso, el segundo objeto (persona2) lo definimos con «Guille» como nombre, si no, no sería igual que el objeto persona1.

Y seguramente pensarás que ¿Para qué quiero el tipo record, si parece que funciona igual que si lo defino como class?

Bien pensado, pero no, los tipos de registro (record) no funcionan igual que los tipos definidos a partir de una definición de una clase (class), y para muestra un botón.

Veamos el ejemplo anterior usando una clase en lugar de un registro.

using System;

var persona1 = new Persona { Nombre = "Guillermo", Edad = 63 };
persona1.Nombre = "Guille";

Console.WriteLine(persona1);

var persona2 = new Persona { Nombre = "Guille", Edad = 63 };

var iguales = persona1 == persona2;
Console.WriteLine("persona1 == persona2 es {0}", iguales);

class Persona
{
    public string Nombre { get; set; }
    public int Edad { get; init; }
}

Si ejecutas ese código (te recuerdo que Persona está declarado con class en lugar de record) el valor asignado a iguales será false.

Y es False porque en realidad son dos objetos por referencia que no usan las nuevas características de los tipos de registro, en el que la comparación de igualdad se hace comprobando los valores campo a campo (o propiedad a propiedad), mientras que en los tipos «clasicos» por referencia se comprueba si el objeto es el mismo, y en este caso, no son el mismo, cada variable hace referencia a un valor diferente en la memoria.

Otra cosa es que escribamos el siguiente código:

using System;

var persona1 = new Persona { Nombre = "Guillermo", Edad = 63 };
persona1.Nombre = "Guille";

Console.WriteLine(persona1);

var persona2 = persona1;

var iguales = persona1 == persona2;
Console.WriteLine("persona1 == persona2 es {0}", iguales);

var iguales2 = persona1.Equals(persona2);
Console.WriteLine("persona1.Equals(persona2) es {0}", iguales2);

class Persona
{
    public string Nombre { get; set; }
    public int Edad { get; init; }
}

En este caso, tanto el valor de iguales como el de iguales2 será True, ya que solo tenemos un objeto en la memoria, pero dos variables que hacen referencia al mismo objeto y por tanto, si cambiamos el valor de la propiedad Nombre en una de las variables ese cambio se hará efectivo en los dos objetos.

Si no me crees añade el siguiente código antes de la definición de la clase Persona y verás lo que muestra ahora.

Console.WriteLine("Antes de la nueva asignación");
Console.WriteLine(persona1.Nombre);
Console.WriteLine(persona2.Nombre);

persona1.Nombre = "Guillermo";

Console.WriteLine("Después de la nueva asignación");
Console.WriteLine(persona1.Nombre);
Console.WriteLine(persona2.Nombre);

Si ejecutas nuevamente el código con estos cambios, la salida será la siguiente:

Antes de la nueva asignación
Guille
Guille
Después de la nueva asignación
Guillermo
Guillermo

Esto demuestra que las dos variables están apuntando al mismo objeto en memoria.

Para terminar, veamos qué ocurre si en lugar de una clase usáramos un tipo record.

¿Te atreves a dar la respuesta a qué mostraría ese código?
No… o sí… bueno veamos el código y el resultado y así salimos de dudas 😉

using System;

var persona1 = new Persona { Nombre = "Guillermo", Edad = 63 };
persona1.Nombre = "Guille";

Console.WriteLine(persona1);

var persona2 = persona1;

var iguales = persona1 == persona2;
Console.WriteLine("persona1 == persona2 es {0}", iguales);

var iguales2 = persona1.Equals(persona2);
Console.WriteLine("persona1.Equals(persona2) es {0}", iguales2);

Console.WriteLine("Antes de la nueva asignación");
Console.WriteLine(persona1.Nombre);
Console.WriteLine(persona2.Nombre);

persona1.Nombre = "Guillermo";

Console.WriteLine("Después de la nueva asignación");
Console.WriteLine(persona1.Nombre);
Console.WriteLine(persona2.Nombre);

record Persona
{
    public string Nombre { get; set; }
    public int Edad { get; init; }
}

Efectivamente, el resultado es como el anterior.

Ya que al hacer la asignación directamente:

var persona2 = persona1;

Estamos compartiendo la misma dirección de memoria en las dos variables, como puedes comprobar, esto no cambia con los tipos por referencia, sean clases o registros.

Y para terminar, solo comentarte que una asignación como esta:

var persona2 = persona1 with { Nombre = "Guille" };

Solo la podemos hacer con los tipos de registro (record) no con las clases (class).

Si lo intentamos con un tipo Persona definida como class el error sería:

Error CS8858: The receiver type 'Persona' is not a valid record type.

Y con esto te dejo por hoy… espero que te hayas aclarado un poco y si no es así… lo siento, pero no sé cómo explicarlo mejor… y si me surge cómo explicarlo mejor, no dudes que te lo explicaré… todo será cuestión de ir practicando con el nuevo tipo de C# 9.0.

En cualquier caso, como siempre, ¡Espero que te haya sido de utilidad! esa es siempre la intención 😉

Nos vemos.
Guillermo

El código fuente con todo el código usado en el artículo

Lo he publicado en github: Novedades de C# 9.0