• Expresiones
• Estructuras
• Funciones
• Extra
• Código fuente de ejemplo

(Actualizado a 10 de Agosto de 2024)

Características adicionales que no encajan en otros apartados

Configuración de tipos de referencia Nullable

Son una característica nueva que permite una mayor gestión a la hora de decirle al compilador cuando una variable es nula o no.

Esto es muy útil a la hora de crear librerías para mostrar advertencias a los usuarios sobre posibles efectos en el uso de las funciones en el manejo de valores nulos.

Esta característica está pensada para .Net Core 3 y .Net Standard 2.1. Si hay algún problema se puede configurar explicitamente la versión del lenguaje a usar.

<PropertyGroup>
    <LangVersion>8.0</LangVersion>
</PropertyGroup>

A partir de aquí hay dos opciones para habilitar esta característica. La primera está pensada para proyectos que ya están en marcha, así que lo que se hace es habilitarlo a nivel de proyecto con:

<PropertyGroup>
    <Nullable>enable</Nullable>
</PropertyGroup>

Y luego deshabilitarlo en cada fichero incluyendo:

#nullable disable

Esto generará avisos por el código, una vez que se han corregido todos se puede eliminar la directiva en cada fichero.

La segunda opción es la inversa, es decir, habilitarlo en ficheros individuales:

#nullable enable

Esto se hace en cada fichero hasta que todos estén anotados y las advertencias del compilador corregidas y entonces se habilita en el proyecto y se eliminan de los ficheros:

<PropertyGroup>
    <Nullable>enable</Nullable>
</PropertyGroup>

En un contexto nullable como el que se ha habilitado hay que tener en cuenta:

• Cualquier variable por referencia es una referencia no nullable.
• Caulquier referencia no nullable puede ser desreferenciada de una forma segura.
• Un tipo de referencia nullable (usando ? como string?) puede ser nula. Durante un análisis estático se verifica si el tipo puede ser nulo de cara a mostrar o no una advertencia.
• Se puede usar el operador ! para indicar que una referencia no será nula (se verá más adelante).

Tipos de referencia Nullable

Ahora partimos de la siguiente interfaz:

namespace UpToDate.Helpers
{
    public interface ISer<in T, out U>
        where T : notnull
        where U : notnull
    {
        U MagicCast(T input);
    }
}

Hemos indicado que tanto T como U no pueden ser nulos, por lo tanto solo se aceptarán valores no nulos o tipo valor (string?, int? darían error).

Se puede usar también la restricción class como se ve en el ejemplo pero en este caso solo podría ser un tipo referencia y no valor.

Esto también obliga a que cualquier clase que lo implemente debe incorporar las mismas restricciones para evitar los avisos del compilador como se pueden ver en las restricciones añadiendo notnull.

public class Sorcerer<T, U> : ISchool<T, U>
    where T : notnull
    where U : class
{
    private string name = string.Empty;
    [AllowNull]
    public string Name
    {
        get
        {
            return name;
        }
        set
        {
            name = value ?? string.Empty;
        }
    }
    public U Cast(T input)
    {
        return (input as U)!;
    }
}

Por lo que esta línea no funcionaría:

return new Sorcerer<string?, float?>();

Pero esta sería correcta:

return new Sorcerer<int, float>();

Nullable preconditions

Algunos atributos son precondiciones, esto quiere decir que solo se aplican a valores de entrada por ejemplo en una propiedad solo se aplicaría a set.

Siguiendo con este ejemplo podemos querer que ciertos valores acepten valores null, para eso es el atributo [AllowNull] de la propiedad Name, el ejemplo anterior evita que la siguiente línea de código de una advertencia:

var sorcerer = new Sorcerer<float, string>();
sorcerer.Name = null;

También se puede trabajar en la dirección contraria, impidiendo asignar valores nulos y emitiendo advertencias, por ejemplo si tenemos este código:

Person? p = null;
sorcerer.LowerName(ref p);

Indicar esa firma de método con [DisallowNull] provocará que el compilador emita una advertencia, hemos convertido la referencia a referencia nullable (usando ?) y después con el atributo impedimos que sea nula, ya que en contextos nullables los tipos referencia se consideran seguros para dereferenciar.

public string LowerName([DisallowNull]ref Person? person)
{
...
}

Nullable postconditions

También se pueden indicar posibles valores en la devolución, por ejemplo se puede indicar que una función puede devolver un valor nulo con [return: MaybeNull], esto es habitual en genéricos sin restricciones como también se verá más adelante, por ejemplo:

[return: MaybeNull]
public Z Find<Z>(Z s)
{
    Z z = default(Z);
    return s!.GetHashCode() > 100 ? s : z;
}

Puede devolver un nulo y por eso lo marcamos como [return: MaybeNull] de tal forma que el código que haga uso de este método emitirá una advertencia, como el siguiente:

public int ReturnNotNull()
{
    var sorcerer = new Sorcerer<float, string>();
    string z = "4";
    var x = sorcerer.Find(z);
    return x.Length;
}

O también podemos indicar que si el valor devuelto es por referencia nunca será nulo usando [NotNull], por ejemplo para este método se está indicando que el parámetro z que se envía por referencia a la función nunca será devuelto como nulo, aunque pueda ser enviado como nulo a la función.

Es decir, independientemente del valor introducido siempre devolvereremos un valor no nulo.

public void Swap<Z>([NotNull]ref Z[]? z)
	where Z : new()
{
    if (z is null)
    {
        z = new Z[] { new Z() };
    }
}

Y podríamos usarlo de forma segura sin avisos ya que hemos indicado que no será nulo:

Person?[] people = null;
extra.Swap(ref people);
Console.WriteLine(people.Length);

Tanto [NotNull] como [MaybeNull] pueden ser usados en valores devueltos en cualquier forma: in, ref, out o return.

Conditional postconditions

Puede ser que queramos indicar si el valor devuelto será nulo o no en función del parámetro de devolución de la función, por ejemplo si la función devuelve true queremos indicar que el parámetro devuelto no será nulo, es una estructura muy típica de las funciones estilo TryXXX(out x).

Por ejemplo queremos indicar que el parámetro devuelto no será nulo cuando la función devuelva false.

public bool IsNullOrEmpty([NotNullWhen(false)] string? value)
{
    return String.IsNullOrEmpty(value);
}

Y lo usaríamos de la siguiente forma para obtener una advertencia al saber que la variable será nula. El compilador sabe que esto es un riesgo porque se ha establecido que no será nulo cuando el valor devuelto sea false.

string? str = null;
if(extra.IsNullOrEmpty(str))
{
    Console.WriteLine(str.Length);
}

Incluso existe el caso de que el parámetro pueda ser nulo aunque el propio tipo no lo permita para eso tenemos [MaybeNullWhen(bool)] , por ejemplo creamos una cola personalizada:

public class CustomQueue<T>
{
    private readonly Queue<T> queue = new Queue<T>();
    public bool TryDequeue([MaybeNullWhen(false)] out T result)
    {
        result = queue.Dequeue();
	return result != null;
    }
}

Entonces una línea como esta mostraría una advertencia ya que intentamos acceder a una variable que sabemos que puede ser nula.

Esto es muy habitual en genéricos donde los tipos pueden ser indistintamente referencia o valor y no hay forma de saber por adelantado si el valor podrá ser nulo o no.

CustomQueue<string> queue = new CustomQueue<string>();
if (!queue.TryDequeue(out var result))
    Console.WriteLine(result.Length);

Dependencias de nulidad entre entrada y salida

Podría ser que quisieramos que un valor de salida fuera nulo en función del valor de entrada, si por ejemplo la entrada no es nula la salida del método tampoco lo será, esto lo hacemos con [return: NotNullIfNotNull(param)]

[return: NotNullIfNotNull("s")]
public string? ToLower(string? s)
{
    if (String.IsNullOrEmpty(s))
        return string.Empty;
    return s.ToLower();
}

O en C# 11 se puede usar nameof para poder referenciar parámetros genéricos

[return: NotNullWhen(nameof(value))]
public T Process<T>(T value, bool condition)
{
    if (condition)
    {
        return value;
    }
    return default(T);
}

Este código lanzaría una advertencia ya que estamos pasando un valor nulo, este valor en este caso viene dado de forma explícita pero podría venir dado desde un parámetro de otra función.

string? toLower = null;
var lower = extra.ToLower(toLower);
Console.WriteLine(lower.Length);

Atributos de flujo

Podría ser que durante el flujo de la ejecución haya un método que haga una comprobación como:

• Emitir una excepción si el parámetro por ejemplo es nulo.
• Una función del tipo assert que emitirá una excepción dependiendo de un booleano de entrada, por ejemplo un true lanzaría una excepción pero un false no.

[DoesNotReturn]
public void ThrowLowerException(string s)
{
    throw new ArgumentException(s);
}

public void AssertIsLower([DoesNotReturnIf(false)] bool s)
{
    if (s)
        throw new ArgumentException("Lower string");
}

En el primer caso indicamos que no hace falta verificar el valor de retorno ya que será una excepción, y en el segundo indicamos que no hace falta realizar ninguna comprobación si el parámetro de entrada es false ya que la ejecución del código terminará en ese punto.

Null forgiveness operator (!)

Habíamos visto un operador ! este operador sirve para indicar que el parámetro no es nulo y no lo va a ser, es una forma de evitar algunas advertencias si sabemos de antemano que ese valor no puede ser nulo.

Se suele usar en pasos intermedio mientras la librería se prepara siguiendo los pasos anteriores, pero a medida que se normalize usando los atributos este operador debería ir desapareciendo.

Referencias:

• Try out Nullable Reference Types
• Nullable reference types
• Nullable Analysis

Top level statements (C# 9)

Cuando se crea una aplicación hay que añadir una cierta cantidad de código que algunas veces no es necesario, ahora se puede evitar y simplificar, por ejemplo, un código clásico como:

using System;

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

Se quedaría en algo como:

using System;

Console.WriteLine("Hello World!");

System.Console.WriteLine("Hello World!"); // More succintly

Esto solo se puede hacer para un único fichero, así que es especialmente útil para aplicaciones de consola (mantiene el uso de args[] y se pueden devolver valores) o pequeños scripts como los que se pueden ver en Azure Functions o Jupyter Notebook.

Cualquier novedad interesante para tratar con funciones.

Información de contexto

Es posible obtener información de contexto sobre la llamada a una función.

public void WriteMessage(string messageBefore,
[System.Runtime.CompilerServices.CallerMemberName] string memberName = "",
[System.Runtime.CompilerServices.CallerFilePath] string sourceFilePath = "",
[System.Runtime.CompilerServices.CallerLineNumber] int sourceLineNumber = 0)
{// C# 5
    Console.WriteLine("parameter before: " + messageBefore);
    Console.WriteLine("caller: " + memberName);
    Console.WriteLine("source file path: " + sourceFilePath);
    Console.WriteLine("source line number: " + sourceLineNumber);
    Console.WriteLine("parameter after: " + messageAfter);
}

/* El resultado es:
parameter: Example
member name: Main
source file path: C:\repos\UpToDate\src\UpToDate\Program.cs
source line number: 28
*/

Existe también la opción de indicar un parámetro que el compilador reemplaza con la representación de texto de otro argumento, en este caso si no se cumple la validación (condition = false) en el mensaje se pondrá como texto el nombre de la variable que se usó como parámetro validateSomethingInteresting

public void Validate(bool condition, [CallerArgumentExpression("condition")] string? message = null)
{
    if (!condition)
    {
        throw new InvalidOperationException($"Argument failed validation: <{message}>");
    }
}

bool validateSomethingInteresting = false;
try
{
    functions.Validate(validateSomethingInteresting);
}
catch(Exception e)
{
    Console.WriteLine(e.Message); // Argument failed validation: <validateSomethingInteresting>
}

Propiedades

Las propiedades aceptan inicializadores, código que asigna un valor inicial, este código tiene que ser estático (una constante, una función estática,…)

// Llamando a una función estática
public string Surname { get; set; } = ReturnDiscard(5).ToString();
// O a una constante
public string Surname { get; set; } = "Surname".ToLower();

Declaración y uso de parámetros out

Es posible devolver valores por referencia

public ref string ReturnByReference(int number, string[] names)
{
    return ref names[number]; // return the storage location, not the value
}

// Uso
string[] dummies = new string[] { "John", "Doe" };
ref var refString = ref functions.ReturnByReference(1, dummies);
refString = "surname"; // Esto modifica el elemento 1 del parámetro dummies
System.Console.WriteLine(dummies[1]);

/* El resultado es:
surname
*/

También es posible que este no sea el comportamiento deseado y no se quiera poder modificar el valor retornado, se puede usar readonly para esto:

public ref readonly string ReturnByReferenceReadonly(int number, string[] names) // 'readonly' es la palabra clave
{
    return ref names[number];
}

// Uso
string[] dummies = new string[] { "John", "Doe" };
var refString = functions.ReturnByReferenceReadonly(1, dummies);
refString = "surname"; //Esto no modificará el elemento 1
System.Console.WriteLine(dummies[1]);

/* El resultado es:
Doe
*/

Funciones locales

Es posible crear funciones locales, es decir funciones que existen dentro de otras.

// Función local auto-implementada
public int LocalFunctionsAuto(int a, int b)
{
    int Sum(int a1, int b1) => a1 + b1;
    return Sum(a, b);
}
// Función local
public int LocalFunctionsRegular(int a, int b)
{
    int Sum(int a1, int b1) {
        return a1 + b1;
    }
    return Sum(a, b);
}

Parámetro in

Un parámetro in no se puede modificar por la función que lo usa, por lo tanto tiene que ser inicializado antes de ser enviado a la función, digamos que es un readonly para la función que lo usa.

public void InParameter(in int o)// Because of 'in' o can not be modified
{
    //o = 3; Esto provocaría un error CS8331
    Console.WriteLine(o);
}
// Uso
functions.InParameter(66);

/* El resultado es:
66
*/

Devolviendo múltiples valores

Se pueden devolver varios valores desde una función, la función llamadora recibirá un objeto de la clase Tuple.

public (int, double) Average(int[] values)
{
    return (values.Length, values.Average()); 
}

// Uso
var items = Average(new int[] { 1, 2 });
Console.WriteLine($"For {items.Item1} elements the average is {items.Item2}");

/* El resultado es:
For 2 elements the average is 1.5
*/

Deconstructores

Se puede deconstruir un objeto y devolver una tupla de elementos, para esto hace falta una función especial llamada Deconstruct si se quiere por ejemplo extraer dos valores esta función aceptará dos parámetros.

// Esta función establecerá los valores a devolver
public void Deconstruct(out string firstName, out string lastName)
{// It can be also an extension method
    firstName = FirstName.ToLower();
    lastName = LastName.ToLower();
}

// Uso
DataStructures dataStructures2 = new DataStructures("John", "Doe");
var (f, l) = dataStructures2;
System.Console.WriteLine(f); // => FirstName.ToLower()
System.Console.WriteLine(l); // => LastName.ToLower()

/* El resultado es:
john
doe
*/

De igual forma se pueden crear métodos Deconstruct con más parámetros que asignarán más valores a variables.

[C#10] No hace falta que se asignen todos los parámetros, por ejemplo:

int x = 0;
(x, int y) = point;

Private protected

Nuevo modificador de accesibilidad que permite que un método sea llamado tanto desde la propia clase como desde una clase que herede de esta siempre y cuando estén en el mismo ensamblado.

private protected string Example()
{// Este método solo puede ser llamado por un padre en el mismo ensamblado
    return "Private protected";
}

Funciones locales estáticas

Ahora es posible crear funciones locales estáticas, esto impide hacer uso de las variables del ámbito padre al contrario que las funciones no estáticas, de lo contrario se generaría un error.

public int Father()
{
	int a = 1;
	int b = 2;
	return Son(a, b);

	static int Son(int c, int d) => c + d;
}

Inicializador de módulos (C# 9)

Ahora se pueden inicializar módulos a través de funciones marcadas con el atributo [ModuleInitializer] estas funciones se ejecutarán antes que cualquier otro método en el módulo, por ejemplo este código será el primero que se ejecute antes que cualquier otro.

[ModuleInitializer]
public static void Start()
{
    System.Console.WriteLine("I'm the first one");
}

• Expresiones
• Estructuras
• Funciones
• Extra
• Código fuente de ejemplo

(Actualizado a 10 de Agosto de 2024)

Por ejemplo novedades en tuplas, interfaces, structs…

Tuplas

Se pueden crear tuplas directamente, una tupla almacena una colección de valores, no confundir con el tipo Tuple (que es una clase y por lo tanto tipo referencia) este tipo realmente es ValueTuple y es una estructura (paso por valor).

Se pueden establecer nombres a los elementos o declararlos de forma anónima.

string a = "A";
string b = "B";
var tuple = (a, b); // Tupla si nombre

System.Console.WriteLine(tuple.a); // Se usa el nombre de la variable
System.Console.WriteLine(tuple.b);

/* El resultado es:
B
*/

var tupleNamed = (key: a, value: b); // Tupla con nombre
System.Console.WriteLine(tupleNamed.key);
System.Console.WriteLine(tupleNamed.value);

/* El resultado es
A
B
*/

Las tuplas tienen características especiales, por ejemplo es posible compararlas, la comparación es por estructura y valor, es decir mismos elementos y mismo valor.

Los elementos pueden estar en otra ubicación si tienen nombre asignado y se pueden relacionar sino será una comparación posicional.

var tuple1 = (key: "1", value: "1.1");
var tuple2 = (key: "1", value: "1.1");
Console.WriteLine(tuple1 == tuple2 ? "Equals" : "Not Equals");

/* El resultado es
Equals
*/

Structs

Un struct puede ser de tipo lectura, en ese caso no se puede modificar ningún valor del mismo y por lo tanto debería ser inicializado por completo dentro del propio struct, por ejemplo en el constructor.

 public readonly struct Person
{
    public string Name { get;  }
    public string Surname { get; }
            
    public Person(string name, string surName)
    {
        this.Name = name;
        this.Surname = surName;
    }
}

// Uso
DataStructures.Person structure = new DataStructures.Person("John", "Doe");
Console.WriteLine(structure.Name);
Console.WriteLine(structure.Surname);

/* El resultado es
John
Doe
*/

También es posible marcar más elementos como readonly esto obliga a que si un método es marcado como readonly no se pueden asignar valores dentro del mismo.

public struct Animal
{
    public string Genre { get; set; }
    public string Specie { get; set; }

    public Animal(string genre, string specie)
    {
        this.Genre = genre;
        this.Specie = specie;
    }

    public readonly string FullString()
    {
        // Specie = "EE"; Esta línea produciría un error.
        return $"{Genre} -> {Specie}";
    }
}

También hay que tener en cuenta que usar elementos no marcados como readonly dentro de métodos marcados como readonly generan una copia del mismo lo cual puede producir una penalización en el rendimiento.

[C#10] Se pueden crear structs sin tener que crear constructores con todos los parámetros. Esta inicialización se puede combinar, inicializando algunos valores en el constructor y otros directamente en las propiedades. Se pueden incluso crear arrays que se inicializarán a los valores por defecto de la estructura.

public readonly struct PersonStruct
{
    public string Name { get; }
    public string Surname { get; } = "Goodbye";

    public PersonStruct()
    {
        Name = "Hello";
    }

    public PersonStruct(string name, string surName)
    {
        this.Name = name;
        this.Surname = surName;
    }
}

var ps = new PersonStruct[2];
Console.WriteLine(string.Join(", ", ps)); // Shows (), ()

Otra forma de inicializar es no crear ningún constructor, declarar la variable e inicializar los valores antes de usarla.

public struct Address
{
    public string Street;
    public int Number;
    public double Distance;

    public override string ToString() => $"{Street} ({Number}) in {Distance}";
}

Address address;
address.Street = "Street";
address.Number = 66;
address.Distance = 100.9;

Console.WriteLine(address.ToString()); // Shows Street (66) in 100,9

También se puede usar la instrucción with para crear una copia como en record. [C# 10] el operador de la izquierda puede ser un tipo anónimo.

Interfaces

Es posible crear interfaces con implementaciones por defecto, por ejemplo en caso de querer ampliar una interfaz existente se puede añadir un nuevo metódo con una implementación por defecto por lo que las clases que implementen esta interfaz no se verán afectadas.

Por ejemplo, teniendo una interfaz como:

public interface IActions
{
    public double Walk();
    public double Run();
}

De hecho ahora es posible tener cualquier modificador de acceso así como variables y funciones estáticas, por ejemplo para parametrizar el uso del código cliente cuando use la interfaz o incluso que los métodos puedan ser sobreescritas marcándolos como protegidos como se puede ver en la función DefaultFlight(…)

public interface IActions
{
    private static int targetDistance = 0;
    public static void SetTravel(int travel)
    {
        if (travel > 10)
            targetDistance = 20;
        else
            targetDistance = 30;
    }
    public double Walk();
    public double Run();
    /// <summary>
    /// Implementación por defecto para clases antiguas.
    /// </summary>
    public double Flight(int miles) => DefaultFlight(this);
    protected static double DefaultFlight(IActions actions)
    {
        return 10 * targetDistance;
    }
}

En este caso cremos una clase que implemente la primera versión de la interfaz pero no la segunda:

public class Lion : IActions
{
    public double Run()
    {
        return 2;
    }
    public double Walk()
    {
        return 1;
    }            
}

En este caso para poder acceder a este código por defecto tendríamos que usar directamente la referencia a la interfaz que es la que tiene el código:

IActions ilion = lion as IActions;
Console.WriteLine(ilion.Flight(0));

Miembros virtuales en interfaces (C# 11)

Ahora se pueden definir operadores sobrecargados u otros miembros estáticos, y estas interfaces a su vez se pueden usar como restricciones para crear tipos genéricos que usan operadores o métodos estáticos. Por ejemplo podríamos hacer esto:

public interface IGetNext<T> where T : IGetNext<T>
{
    static abstract T operator ++(T other);
}

Y podríamos usarlo en un struct así:

public struct RepeatSequence : IGetNext<RepeatSequence>
{
    private const char Ch = 'A';
    public string Text = new string(Ch, 1);

    public RepeatSequence() {}

    public static RepeatSequence operator ++(RepeatSequence other)
        => other with { Text = other.Text + Ch };

    public override string ToString() => Text;
}

Esto se puede usar para crear algoritmo matemáticos genéricos, aquí un ejemplo completo:

    public record Translation<T>(T XOffset, T YOffset) : IAdditiveIdentity<Translation<T>, Translation<T>>
        where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
    {
        public static Translation<T> AdditiveIdentity =>
            new Translation<T>(XOffset: T.AdditiveIdentity, YOffset: T.AdditiveIdentity);
    }


    public record Point<T>(T X, T Y) : IAdditionOperators<Point<T>, Translation<T>, Point<T>>
        where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>
        {
            public static Point<T> operator +(Point<T> left, Translation<T> right) =>
                left with { X = left.X + right.XOffset, Y = left.Y + right.YOffset };
        }

En este ejemplo se puede ver como se usan las interfaces IAdditionOperators<,> que devuelve el elemento identidad y IAdditiveIdentity<,> que contiene los operadores a sobrecargar. Estos cambios han traído de la mano:

1. Crear el operador >>> que permite que permite evitar el casteo de numeros con signo y sin signo.
2. Operador shift relajado, ahora no es necesario que en el operador shift el operando sea int.
3. Operadores checked y unchecked, ahora se pueden utilizar con operadores definidos por el usuario.

Registros (C#9)

Con C#9 tenemos un nuevo tipo de estructura, los registros, estos intentan reforzar la idea de tipos inmutables pero siendo tipos por referencia, en concreto los registros son tipos por referencia inmutables (aunque se pueden hacer mutables) pero teniendo en cuenta que al intentar comparar dos registros con los mismos valores indicará que son iguales.

En el siguiente ejemplo teniendo dos estructuras con los mismos valores, el resultado será «Equals» incluso si se crea un objecto por copia.

PersonStruct personStruct1 = new PersonStruct("John", "Doe");
PersonStruct personStruct2 = new PersonStruct("John", "Doe");
if (personStruct1.Equals(personStruct2)) // GetHashCode()->True
    Console.WriteLine("Equals");
else
    Console.WriteLine("Not equals");

PersonRecord personRecordCopy = new PersonRecord(personRecord1);
if (personRecordCopy == personRecord1)
 // By copy
    Console.WriteLine("Equals");
else
    Console.WriteLine("Not equals");

Aunque es necesario inicializar todas las propiedades sin embargo no será posible modificar propiedades, por ejemplo esto dará error.

personStruct1.Name = "Other name"; // CS0200

De hecho los registros aceptan herencia (y sealed), aunque un hijo heredado tenga los mismo valores será diferente.

Incluso se puede crear un registro sin declarar explícitamente las propiedades (registros posicionales), por ejemplo:

public record Animal(string colour);

Esto crea un registro que contiene una propiedad llamada colour y que se inicializa creando un objeto que tendrá un constructor con un parámetro.

También se puede heredar de este registro aunque para eso habrá que sobreescribir algunos métodos y propiedades para indicar si ese registro es igual o no a otros tipos registros cuando se hagan comparaciones.

Aquí se puede destacar la propiedad EqualityContract, esta propiedad devuelve el tipo de la clase hija de tal forma que si el tipo de la hija es el mismo que el del padre y las propiedades son iguales los dos objetos se considerarán iguales.

public record Base(string Foo);

public record Child(string Foo, string Bar) : Base(Foo)
{
    protected override Type EqualityContract => typeof(Base);
}

var b = new Base("Foo");
var c = new Child("Foo", "Bar");
Console.WriteLine(b == c); // True

Los registros soportan características adicionales como uso de Deconstruct() y expresiones with, como detalle con un with se puede crear un objeto exactamente igual. [C# 10] el operador de la izquierda puede ser un tipo anónimo. A la hora de usar with se puede personalizar la copia para que sea por valor en lugar de referencia, en ese caso solo hay que pasar al constructor un parámetro del mismo tipo que el registro y asignar los valores.

PersonRecord clone = person with { }; // Creates a copy
dynamic personRecordCopy = person with { };

Los registros incluyen varios métodos sintetizados.

• Métodos para comparaciones basados en valor
  • Equals, ==, != y el nuevo EqualityContract
• Sobreescritura de GetHashCode()
• Constructor por copia y Clone()
  • El constructor por copia ya comentado.
  • Clone() realmente no tiene este nombre, es generado internamente pero tampoco se puede generar un método Clone() con ese nombre.
• PrintMembers() y ToString()
  • PrintMembers() saca un listado de todas las propiedades del registro
  • ToString() similar a PrintMembers() con un poco de información adicional

[C#10] Los registros pueden ser por tipo referencia (record class) o por valor (record struct) así mismo también se puede indicar que son de solo lectura (readonly record). Aquí que tener en cuenta que por referencia o valor no tienen el mismo comportamiento.

// We define a readonly record struct with 3 properties in a single line
public readonly record struct School(string address, int number, double distance);

[C#10] También se puede hacer sealed sobre el método ToString() en clases derivadas para asegurar que todas las clases usarán la misma implementación.

public record class TeacherRecord : PersonRecord
{
    public sealed override string ToString() => Subject;
}

[C#12] Ahora se puede usar ref readonly principalmente para referencias de solo lectura que se crearon antes de que existiese in