Saltar al contenido

Artículos, tutoriales, trucos, curiosidades, reflexiones y links sobre programación web ASP.NET Core, MVC, Blazor, SignalR, Entity Framework, C#, Azure, Javascript... y lo que venga ;)

18 años online

el blog de José M. Aguilar

Inicio El autor Contactar

Artículos, tutoriales, trucos, curiosidades, reflexiones y links sobre programación web
ASP.NET Core, MVC, Blazor, SignalR, Entity Framework, C#, Azure, Javascript...

¡Microsoft MVP!
martes, 19 de diciembre de 2023
C#

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:

Publicado en Variable not found.

3 Comentarios:

Rfog dijo...

Si el compililador y el jitter son buenos (que lo son), algunas colecciones irán mapeadas en el equivalente al rodata del ejecutable y ni copia hace falta, solo apuntar a él.

MontyCLT dijo...

Personalmente, viniendo de PHP me gusta esta nueva sintaxis, pero que haya muchas maneras distintas de hacer lo mismo es algo que me suele poner nervioso.

int[] y = { 1, 2, 3 };
int[] z = [1, 2, 3];

Este ejemplo demuestra lo absurdo del asunto, que sólo causará inconsistencias, partes del código utilizando una sintaxis y parte del código utilizando otra.

José María Aguilar dijo...

Hola!

Pues sí, tendremos dos formas de expresar lo mismo. Pero, salvo detalles estéticos, no pasa nada por tener "sinónimos" en el lenguaje, son cosas de la evolución ;)

Quizás con el tiempo nos acostumbraremos a esta última opción porque tiene un ámbito de uso más amplio, y el formato "antiguo" quedará para el código legacy. O no, quién sabe ;)

Saludos!