Dentro de una misma solución de Visual Studio podemos ver los comentarios sin problema, sin embargo cuando creamos una librería por ejemplo a través de NuGet también nos interesa que estos comentarios sean visibles para el consumidor de la librería, esto es posible gracias a unos ficheros XML que incluyen estos comentarios.

Estos ficheros XML no se generan de forma automática, para habilitarlos tenemos dos opciones, a través de la interfaz de Visual Studio o modificando el archivo del proyecto (.csproj).

SDK (archivo de proyecto)

La opción más segura es cambiando el fichero de proyecto usnado la etiqueta <GenerateDocumentationFile>, esto generará los ficheros XML en la ruta adecuada para el proceso de creación del paquete (dotnet pack, nuget pack,…)

<Project>
  <PropertyGroup>
    <!-- Allows to see coments in code -->
    <GenerateDocumentationFile>true</GenerateDocumentationFile>
    <!-- Optional directory path, only if necessary -->
    <DocumentationFile>$(OutputPath)\$(AssemblyName).xml</DocumentationFile>
  </PropertyGroup>
</Project>

Esto puede ser hecho de forma global usando un fichero Directory.Build.props colocado en la raíz de la solución, por ejemplo añadiendo el contenido del ejemplo anterior todos los proyectos de la solución generarán la documentación.

<DocumentationFile> indica la ruta donde se colocarán los ficheros XML, pero como se ha comentado antes es mejor no usarla.

Visual Studio

En este caso usamos la interfaz, simplemente vamos a las propiedades del proyecto a la sección Build y marcamos XML documentation file, que equivale al tag <GenerateDocumentationFile> esto automaticamente rellenará el campo con una ruta por defecto que equivale al campo <DocumentationFile> .

Hay que tener en cuenta que esta configuración es para Debug así que para otras configuraciones habrá que hacer lo mismo.

También es recomendable habilitar los analizadores de código para que muestren avisos de todos los métodos públicos que tendrían que estar documentados.

Sandcastle

SandCastle es una herramienta desarrollada por Microsoft que genera documentación de forma automatizada en un formato similar al que podemos ver en la propia documentación de referencia oficial de Microsoft, Sandcastle se puede descargar desde: https://github.com/EWSoftware/SHFB

En la sección Build seleccionamos la versión de framework que vamos a usar y la carpeta donde guardaremos el log, es útil colocarlo en la misma carpeta que el archivo de proyecto pero no es necesario asociarlo al código fuente, hay que indicar en este caso Fixed Path para que no lo ubique en la ruta por defecto sino en la indicada.

Indicamos también en que formato queremos mostrar la documentación, según como queramos publicar la documentación elegiremos uno u otro (web, html help,…).

En el panel Project Explorer dentro de Documentation Sources sacamos el menú contextual y agregamos los archivos xml de documentación y los ensamblados que harán falta posteriormente para que Sandcastle pueda usar reflection de cara a generar por ejemplo la información de los namespaces que se verá más adelante.

Dentro de References podemos agregar otros proyectos o ensamblados a los que se haga referencia pero de los cuales no se quiera generar documentación.

En la sección Help File es donde indicaremos información relativa al archivo de documentación.
Indicamos los campos Help Title que es el título para la documentación, el nombre del archivo generado en Help file name y el idioma en Help file language.
Podemos indicar campos opcionales como Feedback e-mail address para indicar quien es el autor de la documentación, así como un texto asociado a esta dirección en Feedback e-mail link text.

En la sección Summaries vamos a indicar un texto para los namespaces ya que Visual Studio por defecto no permite comentarlos y Sandcastle genera mensajes de advertencia. Usando el botón Edit namespace summaries podemos seleccionar el namespace que queramos comentar junto con un texto asociado.

La documentación generada se ubicará en la carpeta help dentro de la carpeta que hayamos especificado.

En la salida (pestaña Build Output) se pueden ver los errores generados, habitualmente enlaces incorrectos.

Simplemente usando el comentario triple /// en la cabecera de una estructura de código (clase, método,…) automáticamente se generará la base del comentario, como dato adicional los namespaces no se pueden comentar.

Estos comentarios que generemos se guardarán en ficheros XML, por lo tanto al comentar hay que tener en cuenta que algunos caracteres pueden dar error, por ejemplo ‘<’ se convierte en < y ‘>’ se convierte en &gt;

También comentar que algunas de las etiquetas que se van a explicar pueden no mostrarse correctamente a través de IntelliSense pero si se verán correctamente en la documentación final.

Uso de enlaces

Cualquier etiqueta de documentación es susceptible de usar el atributo cref, este atributo tiene ciertas características para hacer referencia a otros elementos de código como se verá más adelante, por ejemplo para agregar una referencia a un tipo genérico usaríamos:

<see cref="Robot{T}" />

La lista a continuación son prefijos que se pueden agregar para especificar el tipo de código al que se hace referencia, si está bien referenciados no hace falta ya que el compilador lo agrega automáticamente, dependiendo del tipo de enlace se usará un prefijo u otro:

Clave	Descripción
N	Namespace
T	Tipo: clase, interfaz, estructura, enumerado, delegado
F	Campo
P	Propiedad
M	Método (incluyendo constructores, operadores,…)
E	Evento
¡	Cadena de error, generado por el compilador cuando hay un error

Por ejemplo, para un tipo se podría usar:

<see cref="nCubed.Core.Exceptions.SemanticException"/>

En caso de que se haga una referencia a código de .NET, para que Sandcastle lo encuentre correctamente se haría así:

<see cref="T:System.Func`1"/> to be processed.

También se puede usar para hacer referencia a un método de una interfaz genérica:

<see cref="nCubed.Core.Expressions.IAnyEnumerableCollection`1.Any"/>

Si hay dos parámetros genéricos se haría:

<see cref="nCubed.CQRS.Infrastructure.ProcessManagerRepository`2"/>

Cuando se hace referencia a métodos

<see cref="M:System.Object.Equals(System.Object)"/>

Referencia

A continuación la referencia de las etiquetas disponibles, todas las etiquetas se explican con la misma estructura:

• Nombre de la etiqueta.
• Descripción.
• Ejemplo de sintaxis.
• Imagen de ejemplo del resultado en documentación en línea creada con SandCastle (muy similar a MSDN) y en Visual Studio si aplica.

<summary>

Describe un tipo o miembro del mismo. Este texto es el único origen de información para IntelliSense, y se muestra también en Object Browser Window. Admite también el atributo cref. Es el elemento por defecto que aparece al empezar la documentación con ///

<c> <code>

El texto indicado representa código y se representará como tal, con el estilo de letra para código, si se usa <code> aparecerá encuadrado. Ejemplo:

<example>

Crea un ejemplo para la documentación, si es para crear un ejemplo de código es recomendable usarlo junto con la etiqueta <code>.

<exception>

Sirve para indicar que excepciones se lanzarán, se puede usar con métodos, propiedades, eventos e índices. Se puede usar el atributo cref que permite indicar una referencia a una excepción.

<include>

Permite incluir comentarios adicionales en otro archivo, esto es útil para poder usar varios ficheros a la vez y no incluir los comentarios directamente en código.

Se usan los siguientes atributos: file con el nombre del fichero adicional y path con la ruta XPath al comentario de código.

Al compilar el contenido el fichero referenciado se incrusta en la sección que hace la referencia como si se hubiera escrito directamente.

A través de XPath accedemos a la estructura xml que contiene la documentación propiamente dicha en el formato esperado. Un ejemplo de sintaxis es:

<include file='filename' path='tagpath[@name="id"]' />

Y si creamos un documento XML como:

<?xml version="1.0"?>
<CustomDoc>
    <CustomMember name="Animal">
	<summary>
		Full documentation for Animal class.
	</summary>
    </CustomMember>
</CustomDoc>

Tendríamos este resultado:

<list>

Permite crear una lista, el elemento <list> admite varios valores bullet/number/table cada uno de los cuales genera la lista en un formato diferente, no numerada, numerada o en formato tabla. Solo si se usa la opción table tiene sentido usar la etiqueta listheader, term y description se pueden considerar como una etiqueta del estilo clave/valor.

<para>

Se usa dentro de otras etiquetas como <summary> <remarks> <returns>  para agregar estructura al código, como crear párrafos.

<param>

Sirve para agregar información al parámetro de una función.

<paramref>

El nombre de parámetro al que se quiere hacer referencia, es útil para indicar en etiquetas <summary> o <remarks>, por defecto en Sandcastle aparece en cursiva.

<typeparam>

Sirve para comentar un tipo genérico o describir un parámetro de tipo. Se agrega una etiqueta para cada parámetro de tipo. El texto se mostrará en IntelliSense, y en Object Browser Window.

<permission>

Útil para documentar el acceso a un miembro, hay que indicar la clase que gestiona el acceso, para esto se usa habitualmente la clase PermissionSet.

<remarks>

Se usa para agregar información adicional sobre un tipo, proporcionando más  información que la suministrada por <summary>. Esta información se muestra en Object  Browser Window.

<returns>

Representa el valor devuelto por la función.

<see>

Permite especificar un enlace dentro de un texto, el atributo cref permite crear hipervínculos a páginas de documentación.

<seealso>

Para indicar el texto que se mostrará en la sección See Also.

<value>

Describe el valor que representa una propiedad.

Referencias

Recommended Tags for Documentation Comments:
https://msdn.microsoft.com/es-es/library/5ast78ax.aspx
How to: Use the XML Documentation Features (C# Programming Guide)
https://msdn.microsoft.com/es-es/library/z04awywx.aspx

Aquí incluyo expresiones que son relativamente nuevas o no muy conocidas, no pretende ser un listado formal ni tampoco preciso en el término expresiones.

Propiedades

Se pueden usar expresiones para asociar código a varios elementos incluyendo propiedades (auto properties), en este ejemplo se asocia código a la propiedad Name usando una variable de clase (o variable miembro), este código devolverá el valor de la variable o lo establecerá con el valor proporcionado. También se puede usar para funciones y otros elementos de código.

Otro asunto diferente son los inicializadores de propiedad donde la propiedad simplemente coge un valor inicial por defecto como se ve en la propiedad Surname.

public class Sample
{
    private string name = "First";
    public string Name
    {
        get => name;
        set => name = value;
    }
    public string Surname { get; set; } = "Surname";
}

Modificador required

Este es un nuevo modificador que obliga a los consumidores de una clase a utilizar las propiedades marcadas como required esto evita tener que crear constructores personalizados para cada combinación y también evita tener que crear un excesivo código en las clases heredadas llamando a los constructores.

public class Person
{
// The default constructor requires that FirstName and LastName be set at construction time
    public required string FirstName { get; init; }
    public string MiddleName { get; init; } = "";
    public required string LastName { get; init; }
}

Condición ternaria por referencia

Es conocida la expresión: a = exp ? b : c; donde se asigna a la variable a el resultado de b o c dependiendo de la expresión exp, si es cierta se asignará b y si es falsa se asignará c. Por ejemplo:

var a = 12;
var b = 3;
var c = 6;
int res = (a > 10) ? b : c;

Tendría este equivalente usando la sentencia if:

int a = 12;
int res = 0;
if(a > 10)
{
  res = b;
}
else
{
  res = c;
}

También es posible hacerlo usando referencias en lugar de paso por valor, por ejemplo:

var a = 12;
var b = 3;
var c = 6;
ref int res = ref (a > 10) ? ref b : ref c;
res = -1; // Ahora c vale -1

En este caso se devuelve c, pero no el valor de c, es decir, se devuelve la referencia por lo tanto la última línea de código está modificando c no la variable res.

Null coalescing

Más conocida es esta expresión:

object b = a ?? new string("Null!");

En este caso si la variable a es null la variable b cogerá el valor de la expresión, en este caso new string(«Null!») esto es equivalente a:

if (a == null)
{
  b = new string("Null!");
}

También muy útil para verificar parámetros nulos en métodos y lanzar excepciones:

object a = null;
object b = a ?? throw new ArgumentNullException("Object null.");

También es posible asignar directamente el valor, por ejemplo esta expresion:

if (variable is null)
{
    variable = expression;
}

Es equivalente a:

variable ??= expression;

Parámetro out

Muchas veces sobre todo para hacer casting entre tipos se usa la variable out lo que obliga a declarla previamente, ya no es necesario hacer:

int i = -1;
if (int.TryParse(numericValue, out i))
    return i;
return -1;

Se puede hacer lo siguiente:

if (int.TryParse(numericValue, out int i))
    return i;
return -1;

Interpolación

Es conocida la posibilidad de usar de usar el operador $ para sustituir variables en cadenas de caracteres al estilo String.Format, por ejemplo:

var value = 100.435678M;
WriteLine($"You called with => {value:N3}"); // Saca 100.436
WriteLine($"\n\n{"*",-3} Hola {"*",3}"); // Imprime '*   Hola   *'

A partir de la versión 8, este operador se puede combinar con $ en cualquier orden, por lo que $@ y @$ son intercambiables.

[C# 10] Es posible también crear interpoladores personalizados, los valores de la interpolación llaman a String.Format() ahora este comportamiento se puede personalizar.

[C#10] También se puede hacer con constantes, solo con cadenas que también sean constantes y no con números.

[C#11] Ahora se pueden agregar líneas en la interpolación, por ejemplo:

string message = $"The usage policy for {safetyScore} is {
    safetyScore switch
    {
        > 90 => "Unlimited usage",
        > 80 => "General usage, with daily safety check",
        > 70 => "Issues must be addressed within 1 week",
        > 50 => "Issues must be addressed within 1 day",
        _ => "Issues must be addressed before continued use",
    }
    }";

[C# 11] Incluir literales en cadenas, como:

int X = 2;
int Y = 3;

var pointMessage = $"""The point "{X}, {Y}" is {Math.Sqrt(X * X + Y * Y):F3} from the origin""";

Console.WriteLine(pointMessage);

Raw string literals

Hay más control sobre los literales de cadena, se crea una nueva forma usando «»» (triple comilla) que colocará el texto exactamente como se indica, la triple comilla tiene que ir sola al principio y al final, el resto del texto puede ir indentado, las comillas finales marcan la primera columna, no puede haber texto colocado antes.

string longMessage = """
    This is a long message.
    It has several lines.
        Some are indented
                more than others.
    Some should start at the first column.
    Some have "quoted text" in them.
    """;

Indicar utf8

Ahora se puede indicar que una cadena tiene que ser utf8:

ReadOnlySpan<byte> AuthWithTrailingSpace = new byte[] { 0x41, 0x55, 0x54, 0x48, 0x20 };
ReadOnlySpan<byte> AuthStringLiteral = "AUTH "u8; AuthStringLiteral = "AUTH "u8;

Hay que usar ReadOnlySpan<T>

Null propagation

Muchas veces se escribe código para comprobar si hay valores nulos, por ejemplo:

object d = null;
var a = new { A = new { B = new { C = d } } };

if(a != null)
  if(a.A != null)
    if(a.A.B != null)
      if(a.A.B.C != null)
        Console.WriteLine($"{nameof(a.A.B.C)} = {C.ToString()}");

Esto se puede simplicar usando el operador ? el código anterior quedaría así (se incluye el opeador nameof() como ejemplo de uso, este operador coge el nombre de la variable para evitar tener que escribirlo). El código equivalente sería:

var a = new { A = new { B = new { C = d } } };
Console.WriteLine($"{nameof(C)} = {a?.A?.B?.C?.ToString()}");

Discard

A veces se crean variables temporales que no se van a usar o se pasan parámetros que no se necesitan en el contexto de una llamada, para este tipo de escenarios existe la opción de descartar esos valores y no usarlos.

 bool b = int.TryParse(integer, out int _);
if (b)
{
    Console.WriteLine("Can be casted.");
}
else
{
    Console.WriteLine("It can not be casted.");
}

También en la devolución de una función (lo que incluye también por ejemplo expresiones lambdas) pero teniendo en cuenta que no puede haber más de un discard en el mismo ámbito (sería como crear dos variables con el mismo nombre).

public double ReturnDiscard(double value)
{
     var _ = Math.Sqrt(value++);
     return Math.Ceiling(_);
}

Conversion de valores

Se puede comparar el tipo y castear un valor dentro de una estructura if directamente, se usará el primero casting que funcione.

public string ConvertUsingIf(object element)
{
    if (element is string s)
        return s.ToUpper();// Casting included in the same line
    else if (element is int i)
        return Math.Abs(i).ToString();
    else if (element is double d)
        return Math.Truncate(d).ToString();
    else
        return string.Empty;
}

Console.WriteLine(structureControl.ConvertUsingIf("Element"));
Console.WriteLine(structureControl.ConvertUsingIf(5));
Console.WriteLine(structureControl.ConvertUsingIf(4.98));

/* El resultado es:
ELEMENT
5
4
*/

Con la sentencia switch se puede conseguir el mismo resultado

public string ConvertToStringUsingSwitch(object element)
{
    switch (element)
    {
        case string s:
            return s.ToUpper();
        case int i:
            return Math.Abs(i).ToString();
        case double d:
            return Math.Truncate(d).ToString();
        default:
            return string.Empty;
    }
}

Console.WriteLine(structureControl.ConvertToStringUsingSwitch("Element"));
Console.WriteLine(structureControl.ConvertToStringUsingSwitch(5));
Console.WriteLine(structureControl.ConvertToStringUsingSwitch(4.98));

/* El resultado es:
ELEMENT
5
4
*/

De hecho con switch incluso podemos añadir algunas condiciones dentro de la conversion.

public string ConvertToStringUsingSwitchWhen(object element)
{
    switch (element)
    {
        case string s when s.Length > 0:
            return s.ToUpper();
        case int i when i > 5: // Entero y mayor de 5
            return Math.Abs(i).ToString();
        case int i: // Cualquier entero
            return Math.Sqrt(i).ToString();
        case double d:
            return Math.Truncate(d).ToString();
        case var o when (o?.ToString().Length ?? 0) == 0:// Usando 'var'
            return "Empty";
        case null: // Comprobando contra 'null'
            throw new ArgumentNullException(paramName: nameof(element), message: "Element must not be null");
        default:
            return string.Empty;
    }
}

Patrones recursivos

Se añade más potencia a los patrones, ahora los patrones de expresiones son recursivos por lo que se pueden aplicar expresiones de patrones a expresiones de patrones.

Para los siguientes ejemplos se usará esta clase:

public class Building : IDisposable
{
    public int Age { get; set; }
    public string State { get; set; }
    public void Deconstruct(out int age, out string state)
    {
        age = Age;
        state = State.ToLower();
    }
    public void Dispose()
    {
        Age = 0;
    }
}

Expresiones Switch

Ahora hay una forma más compacta de expresar un switch.

public Color ExpressionPatterns() =>
    Console.BackgroundColor switch
    {
        ConsoleColor.Red => Color.FromArgb(255, 0, 0),
        ConsoleColor.Green => Color.FromArgb(0, 255, 0),
        ConsoleColor.Blue => Color.FromArgb(0, 0, 255),
        _ => throw new ArgumentException("Invalid value")
    };

[C# 10] Es posible ahora hacer referencia a propiedades anidadas.

public string ExtendedPropertyPattern(Building building)
    => building switch
    {
        { Name.FirstName: "John" } => "ok",
        { Name.FirstName: "Doe" } => "ko",
        _ => "Unknown"
    };

Patrones de propiedad

Es posible usar switch a través de las propiedades de un objeto, por ejemplo con una clase Person que tenga una propiedad Age. Esto devolvería un resultado en función del valor de la propiedad Age.

public int PropertyExpression(Building p) =>
    p switch
    {
        { Age: 10 } => p.Age * 1,
        { Age: 20 } => p.Age * 2,
        _ => 30,
    };

Patrones posicionales

Se puede combinar la funcionalidad de deconstrucción con patrones posicionales dentro de sentencias switch, es decir, se crea el método Deconstruct y se usa dentro de una sentencia switch parecido al manejo de tuplas:

public string PositionalPattern(Building building)
    => building switch
    {
        (0, "") => "No born",
        (15, "A") => "Young female",
        (25, "B") => "Too much older man",
        (_, _) => "No human",
        _ => "Unknown"
    };

Patrones de Tupla

Es posible usar tuplas dentro de switchs:

public static string SwitchTuple(string first, string second)
    => (first, second) switch
    {
        ("one", "two") => "Wins second",
        ("two", "one") => "Wins first",
        (_, _) => "tie"
    };

Patrones avanzados (C# 9)

Poco a poco se ha ido mejorando el uso de patrones y ahora se permite simplificaciones adicionales, por ejemplo:

public bool PatternMatchFunction(string a) =>
    a[0] is (>= 'a' and <= 'z') or (>= 'A' and <= 'Z' and not default(char));

El ejemplo anterior usamos paréntesis para remarcar la precedencia y además se permite también comprobación contra null (x is not null).

Patrones en listas

Ahora se puede hacer encajar un array o lista contra una secuencia de patrones.

int[] numbers = { 1, 2, 3 };

Console.WriteLine(numbers is [1, 2, 3]);  // True
Console.WriteLine(numbers is [1, 2, 4]);  // False
Console.WriteLine(numbers is [0 or 1, <= 2, >= 3]);  // True

O también se puede hacer

List<int> numbers = new() { 1, 2, 3 };

if (numbers is [var first, _, _])
{
    Console.WriteLine($"The first element of a three-item list is {first}.");
}
// Output:
// The first element of a three-item list is 1.

Excepciones

Es posible establecer condiciones dentro de las claúsulas catch para poder filtrar por condiciones concretas:

public void RaiseException(string code)
{
    try
    {
        throw new ArgumentException(code);
    }
    catch (ArgumentException ae) when (ae.Message.Contains("100"))
    {// Mismo tipo (ArgumentException) y valor ("100")
        System.Console.WriteLine($"Error => {ae.Message}");
    }
    catch (ArgumentException ae) when (ae.Message.Contains("200"))
    {
        System.Console.WriteLine($"Error => {ae.Message}");
    }
    catch (ArgumentException ae)
    {// Cualquier otro ArgumentException no incluido antes
        System.Console.WriteLine($"Error => {ae.Message}");
    }
}

Using

Ahora la sentencia using no está limitada por las llaves, durará lo mismo que el ámbito en el que esté contenida la variable creada por using.

El siguiente código devolverá un 0 en su propiedad Age debido al método Dispose de la clase Building.

public Building ShortUsing()
{
    using Building b = new Building()
    {
        Age = 20,
        State = "WA"
    };
    b.Age = 40;
    return b;
}

También se pueden crear using globales, no es más que una forma de declarar un using en un fichero que se aplicará de forma global en todo el proyecto. Una forma útil es crear un fichero solo para los using.

global using System;

[C# 12] Ahora se puede usar using para cualquier tipo no solo tipos con nombre, por ejemplo tuplas, arrays, punteros… por ejemplo:

// The alias is to `List<...>` which is itself not a nullable
// reference type itself, even though it contains one as a type argument.
using Y = System.Collections.Generic.List<string?>;
using Z = int?;

Namespace [C#10]

Ahora es posible eliminar las llaves asociadas a los namespace, así se gana un poco de tabulación y espacio hacia la izquierda. Tip: Solo con poner ; al final del namespace VS limpiará los corchetes.

namespace UpToDate.Demos;
internal class DemoExpression
{...}

Secuencias asincrónicas

Es posible usar await para un bucle que consume una función asincrónica, por ejemplo teniendo este método.

public static async IAsyncEnumerable<string> GenerateWord(string a)
{
    for (int i = 65; i < 97; i++)
    {
        await Task.Delay(100);
        a += (char)i;
        yield return a;
    }
}

Se podría consumir directamente de esta forma:

await foreach (var word in Expressions.GenerateWord("z"))
{
    Console.WriteLine(word);
}

Índices y rangos

Un índice define un elemento dentro de una secuencia, por ejemplo ^0 se refiere al primer elemento, mientras que un rango define una serie de elementos dentro de la secuencia, por ejemplo 0..8 indica los elementos del 0 al 7 ya que el primer elemento siempre se incluye y el último se omite.

var numbers = new string[]
{
    "One",
    "Two",
    "Three",
    "Four",
    "Five"
};

Esto funciona con los siguientes elementos

• string
• Matrices
• Span<T> 
• ReadOnlySpan<T>

var last = numbers[^1]; // The last one ("Five)
var rangeFromBegin = numbers[0..3]; // The first three ("One", "Two", "Three")
var rangeFromEnd = numbers[^2..^1]; // The penultimate element ("Four")
var all = numbers[..]; // All ("One","Two","Three","Four","Five")
var fromBegin = numbers[..2]; // First two ("One","Two")
var middle = numbers[3..]; // From third till end ("Four", "Five")

Range range = 1..4;
var range = numbers[range]; // From second till third ("Two", "Three", "Four")

Index index = ^2;
var index = numbers[index]; // The penultimate element ("Four")

Expresiones en colecciones

Una forma sencilla de agrupar colecciones, sirve para tipos array, Span<> y ReadOnlySpan<> y tipos que se pueden inicializar como colecciones (por ejemplo List<T>), en este ejemplo se concatenan 3 arrays.

int[] row0 = [1, 2, 3];
int[] row1 = [4, 5, 6];
int[] row2 = [7, 8, 9];
int[] single = [.. row0, .. row1, .. row2];
foreach (var element in single)
{
    Console.Write($"{element}, ");
}

Init

Una forma de establecer valores a las propiedades durante la creación del objeto, es útil para inicializar en lugar de usar un constructor o establecer valores en propiedades desde clases derivadas.

Por ejemplo el siguiente código permite inicializar un objeto a través de sus propiedades y después cambiar algunas de ellas menos la marcada como init que dará un error.

public class Building
{
    ...
    public string Name { get; init; } = "None";
    ...
}
Building b = new () { Age = 5, Name = "Chrysler", State = "USA" };
b.Age = 40;
b.Name = "11";
 // CS8852

Scoped

Este es un modificador para tipos por valor (en concreto ref struct) que asegura que el código no extenderá el tiempo de vida de la variable. Solo se puede aplicar a variables locales y parámetros.

Span<char> values = stackalloc char[3] { 'T', 'o', 'm' };
new Test().TestMethod(values);

ref struct Test
{
    public void TestMethod(scoped ReadOnlySpan<char> characters)
    {
        // The body of the method must only use characters in the local scope, and cannot assign it directly to any field or classes unles they themselves would be scoped.
    }
}

Constructores (C# 9)

Se pueden realizar algunas simplificaciones en los constructores si el tipo está bien establecido, por ejemplo está función:

public Building IsNull(Building b)
{
    if(b is null)
        return new();
    else
        return b;
}

Se podría llamar usando:

if (expressions.IsNull(new()) is null)
    Console.WriteLine("Is null");
else
    Console.WriteLine("Is not null");

En todos estos casos donde se usa new() no hace falta indicar el tipo porque está bien definido ya sea a través de los parámetros, el valor de retorno o la propia construcción del objeto.

Constructores primarios

Los constructores primarios permiten declaraciones más compactas eliminando propiedades y añadiéndolas directamente en el constructor, ahora se admiten para estructuras, registros y clases. Por ejemplo lo que antes era:

public readonly struct Distance
{
    public readonly double Magnitude { get; }

    public readonly double Direction { get; }

    public Distance(double dx, double dy)
    {
        Magnitude = Math.Sqrt(dx * dx + dy * dy);
        Direction = Math.Atan2(dy, dx);
    }
}

Ahora se puede hacer asi:

public readonly struct Distance(double dx, double dy)
{
    public readonly double Magnitude { get; } = Math.Sqrt(dx * dx + dy * dy);
    public readonly double Direction { get; } = Math.Atan2(dy, dx);
}

Y podemos asimismo heredar estos constructores o crear varios constructores primarios.

public class EmpireState(decimal height, decimal weight) : Building("WA")
{
    public EmpireState(decimal height, decimal weight, string address) : this(height, weight) { }
}

Lambda

Se incorpora el concepto de tipo natural de tal forma que ya no hace falta indicar expresamente los tipos de parámetros o devolución, por ejemplo:

var parse = (string s) => int.Parse(s); // Equivalent to Func<string, int>

Aunque en algunos casos si se quiere indicar se puede indicar el parámetro de devolución:

var choose = object (bool b) => b ? 1 : "two"; // Func<bool, object>

Ahora también se pueden añadir atributos a la expresión lambda, a parámetros de entrada y al valor de retorno, por ejemplo:

var lambdaAttribute = [Custom("lambda attribute")][return: Custom("return attribute")]int ([Custom("parameter attribute")]string s) => int.Parse(s);

[C# 12] Ahora también se admite parámetros por defecto, por ejemplo:

var IncrementBy = (int source, int increment = 1) => source + increment;

Atributos Genéricos (C# 11)

Ahora se pueden crear atributos genéricos, por ejemplo:

public class GenericCustomAttribute<T> : Attribute { }

Que luego podemos usar como atributo a un método por ejemplo:

[GenericCustom<string>()]
public string ShowCustomAttribute()
{
    return "Custom operation string";
}

A la hora de usar al el atributo tiene que estar construido, (no puede volver a ser genérico) y hay algunas restricciones como que no se puede usar dynamic, string?, (int x, int y)… pero se pueden usar los sustitutos naturales (object, string, ValueTuple<int, int>).

Atributo Experimental

Se puede marcar código como experimental para que saque una advertencia, realmente el compilador mostrará un error que se puede evitar usando la directiva #pragma

[Experimental("DiagID", UrlFormat = "https://example.org/{0}")]
public class GenericCustomAttribute<T> : Attribute { }

#pragma warning disable DiagID
[GenericCustom<string>()]
public string ShowCustomAttribute()
{
    return "Custom operation string";
}