C# Academy · Aula

O elemento de expansão

Combine coleções com o operador de expansão.

O elemento de expansão é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C# Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C# Academy inclui 4 aulas no total.

O elemento de expansão ..

Dentro de uma expressão de coleção, o elemento de expansão .. insere o conteúdo de outra coleção. É assim que sequências são combinadas de forma declarativa.

using System;

int[] a = [1, 2, 3];
int[] b = [4, 5, 6];
int[] all = [..a, ..b];
Console.WriteLine(string.Join(",", all)); // 1,2,3,4,5,6

Combinando expansões e elementos individuais

É possível intercalar livremente elementos de expansão com valores individuais, preservando a ordem.

using System;

int[] middle = [2, 3, 4];
int[] result = [1, ..middle, 5];
Console.WriteLine(string.Join(",", result)); // 1,2,3,4,5

Adicionando no início e no fim

As expansões tornam trivial “adicionar no início” ou “adicionar no fim”, produzindo uma nova coleção em vez de alterar a original.

using System;

int[] core = [10, 20, 30];
int[] withHead = [0, ..core];
int[] withTail = [..core, 40];
Console.WriteLine(string.Join(",", withHead)); // 0,10,20,30
Console.WriteLine(string.Join(",", withTail)); // 10,20,30,40

Expandindo várias fontes

É possível expandir qualquer quantidade de coleções em uma só. Isso concatena várias listas em uma única expressão.

using System;
using System.Collections.Generic;

List<string> x = ["a", "b"];
List<string> y = ["c"];
List<string> z = ["d", "e"];
List<string> merged = [..x, ..y, ..z];
Console.WriteLine(string.Join(",", merged)); // a,b,c,d,e

Expandindo diferentes tipos de coleção

A fonte da expansão pode ser qualquer tipo enumerável: uma matriz em uma lista, uma lista em uma matriz e assim por diante. O tipo de destino controla o resultado.

using System;
using System.Collections.Generic;

int[] arr = [1, 2];
List<int> list = [3, 4];
int[] combined = [..arr, ..list];
Console.WriteLine(string.Join(",", combined)); // 1,2,3,4

Expandindo sequências enumeráveis

Até mesmo sequências adiadas de LINQ podem ser expandidas; elas são enumeradas quando a nova coleção é construída.

using System;
using System.Linq;

var evens = Enumerable.Range(1, 6).Where(n => n % 2 == 0);
int[] result = [0, ..evens];
Console.WriteLine(string.Join(",", result)); // 0,2,4,6

Construindo coleções progressivamente

As expansões são ótimas para uma construção incremental sem chamadas imperativas a Add.

using System;

int[] baseline = [1, 2, 3];
int[] extra = [4, 5];
int[] full = [..baseline, ..extra, 6];
Console.WriteLine(full.Length); // 6

A ordem é significativa

A sequência resultante segue a ordem textual dos elementos e das expansões, portanto trocar as expansões altera a saída.

using System;

int[] a = [1, 2];
int[] b = [3, 4];
Console.WriteLine(string.Join(",", [..a, ..b])); // 1,2,3,4
Console.WriteLine(string.Join(",", [..b, ..a])); // 3,4,1,2

Expansões versus Concat

As expansões geralmente substituem Concat + ToArray. Elas são mais claras e permitem que o compilador dimensione o resultado com eficiência.

using System;
using System.Linq;

int[] a = [1, 2];
int[] b = [3, 4];
// old
int[] oldWay = a.Concat(b).ToArray();
// new
int[] newWay = [..a, ..b];
Console.WriteLine(oldWay.SequenceEqual(newWay)); // True

Expandindo para intervalos

Como o destino pode ser um intervalo, é possível combinar dados com uma possível alocação na pilha em trechos sensíveis ao desempenho.

using System;

ReadOnlySpan<int> head = [1, 2];
ReadOnlySpan<int> tail = [3, 4];
int[] joined = [..head, ..tail];
Console.WriteLine(string.Join(",", joined)); // 1,2,3,4

Uma combinação prática

Aqui combinamos configurações padrão com substituições em uma única expressão, mantendo os valores posteriores depois dos padrões.

using System;

string[] defaults = ["--verbose", "--color"];
string[] userArgs = ["--output=log.txt"];
string[] finalArgs = [..defaults, ..userArgs];
Console.WriteLine(string.Join(" ", finalArgs));

Verificação rápida

Verifique sua compreensão do elemento de expansão.

Recapitulação

Você aprendeu o elemento de expansão .. dentro das expressões de coleção.

[..a, ..b] concatena coleções.
As expansões podem ser combinadas com elementos individuais e preservam a ordem.
As fontes podem ser matrizes, listas, intervalos ou qualquer IEnumerable.
É uma alternativa mais clara a Concat().ToArray().

Perguntas Frequentes

A aula “O elemento de expansão” é grátis?

Sim — o texto completo de “O elemento de expansão” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C# Academy, atualize para CoddyKit PRO. O curso de C# Academy inclui 4 aulas no total.

O que vou aprender em “O elemento de expansão”?

Combine coleções com o operador de expansão. Você pratica C# Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C# Academy?

Nenhuma experiência prévia é necessária. C# Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “O elemento de expansão”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C# Academy?

Sim. Cada aula de C# Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C# Academy