Poco a poco vamos haciéndonos con las novedades de C# 12, y en esta ocasión nos centraremos en una nueva sintaxis que proporciona una forma concisa y rápida para declarar los elementos de una colección.

Ya os adelanto que si sois de los que siempre han envidiado otros lenguajes por la facilidad con la que se declaran los elementos de un colección o array, estáis de enhorabuena ;) Porque, sin duda, hay formas de hacerlo menos verbosas que las que hemos tenido hasta ahora en C#:

// JavaScript:
let numbers = [1, 2, 3];

// Python:
numbers = [1, 2, 3]

// PHP:
$array = [1, 2, 3];

// Rust:
let array = [1, 2, 3];

En C# 11 y anteriores, la creación de un array es normalmente más farragosa, porque de alguna forma u otra requiere que especifiquemos que se trata de un nuevo array y, si la inferencia no lo permite, el tipo de los elementos que contendrá:

// Forma verbosa y redundante:
int[] arr1 = new int[3] { 1, 2, 3 };

// Forma clásica, usando 'var' y especificando número y tipo elementos:
var arr2 = new int[3] { 1, 2, 3 };

// Dejamos que el compilador detecte el número de elementos:
var arr3 = new int[] { 1, 2, 3 };

// Dejamos que la inferencia de tipos determine el tipo de los elementos:
var arr4 = new [] { 1, 2, 3 };

// O bien, la más concisa, usando la sintaxis con llaves (sólo válida para arrays):
int[] arr5 = { 1, 2, 3 };

En C# 12, al igual que en otros lenguajes, podemos usar los corchetes [] en (prácticamente) cualquier lugar donde sea necesario especificar una colección de elementos.

Por ejemplo, en el siguiente código lo usamos en la inicialización de un array, aunque no veremos mucha ventaja respecto a la fórmula más concisa de C#:

// C# 11 y anteriores:
var x = new int[] { 1, 2, 3 };
int[] y = { 1, 2, 3 };

// C# 12:
int[] z = [1, 2, 3];

Sin embargo, en el siguiente código veremos que esta nueva sintaxis cobra más sentido, porque el parámetro del método al que se está llamando recibe un array de caracteres y la inferencia de tipos puede detectarlo. Esto no había una mejor forma de especificarlo en versiones anteriores de C#:

// En C# 11 y anteriores:
var index = "abcd".IndexOfAny(new[] { 'b', 'c'})

// En C# 12:
var index = "abcd".IndexOfAny(['b', 'c']));

Este tipo de declaración puede utilizarse también con otras colecciones, como List<T>, Span<T>, IEnumerable<T>, etc. Es decir, las siguientes líneas son válidas:

List<int> x = [1, 2, 3];
Collection<int> y = [1, 2, 3];
HashSet<int> z = [1, 2, 3];
IEnumerable<int> t = [1, 2, 3];

También es interesante saber que podemos usar esta sintaxis para insertar el contenido de otras colecciones en los datos iniciales usando spreading, gracias al operador doble punto "..":

int[] x = [3, 4, 5];
int[] y = [1, 2, ..x, 6, 7];
Console.WriteLine(string.Join(", ", y)); 
// Muestra: 1, 2, 3, 4, 5, 6, 7

Y, por supuesto, soporta arrays multidimensionales:

int[][] arr = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];

Además, la nueva sintaxis permite que sea el compilador el que decida la forma más eficiente de inicializar la colección, lo que puede suponer una mejora en términos de CPU y memoria en algunos casos.

Sin duda, se trata de una mejora que simplifica el código de inicialización de arrays y otras colecciones, por lo que seguro empezaremos a verla en código ajeno y usarla en el nuestro propio.

¿Mola mucho, verdad?

Más información:

• Collection expressions en C# 12

Publicado en Variable not found.