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.
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.
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.
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.
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"];
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'];
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.
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.
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
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.