Com o C# 12, a criação de coleções em C# foi significativamente simplificada com a introdução das expressões de coleção (collection expressions). Esse novo recurso oferece uma sintaxe mais concisa e intuitiva para criar e manipular coleções, tornando o código mais legível e fácil de manter. Neste artigo exploraremos como as expressões de coleção funcionam.
O que são collection expressions?
As expressões de coleção permitem criar coleções comuns com uma nova sintaxe compacta. Com essa sintaxe, você pode criar “arrays”, “Span<T>”, “List<T>”, e tipos que suportam inicializadores de coleção. Além disso, o operador spread (..) é introduzido para incorporar elementos de outras coleções.
Mudanças com o C# 12
Vamos explorar as mudanças introduzidas pelas expressões de coleção no C# 12, focando em como a nova sintaxe melhora a criação e manipulação de coleções.
Criar um array
Antes: a criação de arrays exigia o uso do construtor new e chaves “{}” para inicializar o array. Isso resultava em uma sintaxe mais longa e verbosa:
int[] numeros = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
Depois: com o C# 12 você pode usar uma sintaxe mais direta com colchetes “[]” para inicializar arrays. Isso reduz a verbosidade e torna o código mais limpo e fácil de ler, eliminando a necessidade de new e as chaves “{}”.
int[] numeros = [1, 2, 3, 4, 5, 6, 7, 8];
Note que ao usar a nova sintaxe de inicialização com colchetes “[]”, a variável não foi declarada como var. Isso ocorre porque o var não é compatível com essa nova expressão de inicialização. O var requer que o compilador infira o tipo da variável com base na expressão à direita, e a nova sintaxe de inicialização não é suportada para inferência de tipo dinâmica.
// Isso gerará um erro de compilação.
var numeros = [1, 2, 3, 4, 5, 6, 7, 8];
Portanto, ao usar essa nova sintaxe, é necessário especificar explicitamente o tipo da variável.
Criar uma lista
Antes: para criar uma “List<T>”, você precisava usar o construtor “new List<T>” e passar uma coleção entre chaves “{}”. Essa abordagem podia ser menos intuitiva e mais sujeita a erros.
List<string> contagem = new List<string> { "one", "two", "three" };
Depois: a nova sintaxe com colchetes para listas é mais concisa e intuitiva. Agora você pode inicializar uma “List<T>” diretamente com colchetes, tornando o código mais compacto e fácil de escrever.
List<string> contagem = ["one", "two", "three"];
Criar um span
Antes: para criar um “Span<T>”, era necessário usar “stackalloc” e colchetes “{}”. Isso envolvia uma sintaxe mais complexa e menos direta.
Span<char> letras = stackalloc char[] { 'a', 'b', 'c', 'd', 'e', 'f', 'h', 'i' };
Depois: o C# 12 simplifica a criação de “Span<T>” com uma nova sintaxe que utiliza apenas colchetes “[]”. Isso torna o código mais limpo e a criação de “Span<T>” mais intuitiva.
Span<char> letras = ['a', 'b', 'c', 'd', 'e', 'f', 'h', 'i'];
Criar um array bidimensional irregular
Antes: a criação de arrays bidimensionais irregulares (ou jagged arrays) envolvia o uso do construtor “new int[][]” e chaves aninhadas. Isso podia resultar em uma sintaxe mais detalhada e menos legível.
int[][] matriz = new int[][]
{
new int[] { 1, 2, 3 },
new int[] { 4, 5, 6 },
new int[] { 7, 8, 9 }
}
Depois: com a nova sintaxe, a inicialização de arrays 2D irregulares é mais direta e legível. Usar colchetes aninhados para criar arrays 2D irregulares simplifica o código e melhora a clareza.
int[][] matriz = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
Essa nova sintaxe também se aplica ao uso de variáveis para inicializar arrays bidimensionais.
Antes:
int[] row0 = new int[] { 1, 2, 3 };
int[] row1 = new int[] { 4, 5, 6 };
int[] row2 = new int[] { 7, 8, 9 };
int[][] twoDFromVariables = new int[][] { row0, row1, row2 };
Depois:
int[] row0 = [1, 2, 3];
int[] row1 = [4, 5, 6];
int[] row2 = [7, 8, 9];
int[][] twoDFromVariables = [row0, row1, row2];
Em vez de usar o construtor “new” para criar arrays e arrays de arrays, você pode usar a nova sintaxe de colchetes, o que simplifica a inicialização e torna o código mais conciso.
Operador spread
O operador spread (..) é um recurso que permite descompactar elementos de uma coleção e incorporá-los em outra. Este operador é útil para combinar várias coleções em uma única coleção.
Veja um exemplo de uso do operador spread para criar um array único a partir de múltiplos 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}, ");
}
// Saída:
// 1, 2, 3, 4, 5, 6, 7, 8, 9,
No exemplo acima, “row0”, “row1” e “row2” são descompactados e seus elementos são incorporados em um novo array single. O operador spread (..) extrai os elementos de cada array e os combina em uma única sequência. Isso é especialmente útil quando você deseja consolidar dados de várias fontes ou criar coleções de forma dinâmica e fluida. O resultado da ação é que o array Single terá dentro de si os valores 1, 2, 3, 4, 5, 6, 7, 8, 9.
Acelere a sua carreira conosco!
Se você é Desenvolvedor .NET Júnior e quer acelerar sua carreira até nível Pleno com salário de R$7k+, ou mesmo busca a primeira vaga, conheça a Mentoria .NET Start: Clique aqui
Se é Desenvolvedor .NET Pleno ou Sênior e quer virar referência técnica em sua equipe e mercado, com salário de R$10k+, conheça a Mentoria .NET Expert: Clique aqui
Conclusão
As expressões de coleção no C# 12 introduzem uma maneira mais concisa e legível para inicializar coleções. Com a nova sintaxe, você pode criar arrays, listas e outros tipos de coleções de maneira mais direta e menos propensa a erros. O operador spread (..) também oferece uma forma poderosa de combinar coleções, facilitando operações como a concatenação de arrays. Essas melhorias não só simplificam o código, mas também ajudam a manter a consistência e clareza em projetos C#. Para mais detalhes, você pode consultar a documentação oficial do C# 12.