C# Academy · Aula

Padrões de listas e tuplas

Desestruture coleções.

Padrões de listas e tuplas é uma aula grátis de C# Academy no CoddyKit. Esta é a aula 4 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.

Padrões de tupla

Um padrão de tupla corresponde a vários valores de uma só vez, colocando-os entre parênteses. Cada posição é comparada com seu próprio subpadrão.

Isso é ideal para decisões que dependem de várias entradas, como uma pequena máquina de estados ou um juiz de pedra-papel-tesoura, tudo em uma única instrução de seleção.

int x = 0, y = 5;
string quadrant = (x, y) switch
{
    (0, 0) => "origin",
    (0, _) => "y-axis",
    (_, 0) => "x-axis",
    _ => "plane"
};
System.Console.WriteLine(quadrant);

Uma seleção de tupla executável

Padrões de tupla tornam as tabelas de decisão fáceis de ler. Aqui, dois valores booleanos escolhem uma ação.

Cada ramo lista um padrão de tupla, e o descarte _ em uma posição significa que essa posição pode conter qualquer coisa. O ramo final _ abrange o restante.

using System;

class Program {
    static string Move(bool fwd, bool turn) => (fwd, turn) switch {
        (true, false) => "straight",
        (true, true) => "curve",
        (false, true) => "spin",
        _ => "stop"
    };
    static void Main() => Console.WriteLine(Move(true, true));
}

Vinculação dentro de tuplas

As posições em um padrão de tupla podem capturar valores. (0, var y) corresponde quando o primeiro item é 0 e associa o segundo a y.

Você pode então usar a variável associada no resultado do ramo ou em uma guarda when, combinando correspondência e extração em uma única etapa.

var point = (0, 7);
string r = point switch
{
    (0, var y) => $"on y-axis at {y}",
    (var x, 0) => $"on x-axis at {x}",
    _ => "elsewhere"
};
System.Console.WriteLine(r);

Padrões de lista

Um padrão de lista corresponde a vetores e listas por meio de seus elementos, escritos entre colchetes: [1, 2, 3]. A correspondência ocorre quando o comprimento e o padrão de cada elemento são compatíveis.

Introduzidos no C# 11, os padrões de lista permitem ramificar diretamente com base no formato de uma sequência, sem verificações manuais de comprimento e índice.

int[] data = { 1, 2, 3 };
string shape = data switch
{
    [] => "empty",
    [_] => "one",
    [_, _] => "two",
    _ => "many"
};
System.Console.WriteLine(shape);

Correspondência de elementos exatos

Padrões de lista podem comparar valores específicos em cada posição. [1, 2, 3] corresponde somente a essa sequência exata de três elementos.

Combine constantes e descartes livremente: [1, _, 3] corresponde a uma lista de comprimento três que começa com 1 e termina com 3, ignorando o elemento do meio.

using System;

class Program {
    static void Main() {
        int[] a = { 1, 9, 3 };
        bool ok = a is [1, _, 3];
        Console.WriteLine(ok);
    }
}

O padrão de fatia

O padrão de fatia .. corresponde a qualquer quantidade de elementos, inclusive zero, em uma posição. Um padrão de lista pode conter no máximo uma fatia.

[1, .., 9] corresponde a qualquer lista que comece com 1 e termine com 9, independentemente do que estiver entre eles. Isso é ótimo para verificações de head e tail.

int[] nums = { 1, 4, 5, 9 };
string r = nums switch
{
    [1, .., 9] => "1..9 bookends",
    _ => "other"
};
System.Console.WriteLine(r);

Capturando uma fatia

A fatia pode capturar os elementos ignorados em uma variável usando var: [first, .. var rest].

A parte capturada é, por si só, um vetor ou uma lista do tipo correspondente, permitindo desestruturar um elemento head e manter o tail para processamento posterior.

using System;

class Program {
    static void Main() {
        int[] xs = { 10, 20, 30, 40 };
        if (xs is [var head, .. var tail])
            Console.WriteLine($"{head} then {tail.Length} more");
    }
}

Vinculação dos elementos nas extremidades

Você pode vincular as duas extremidades ao redor de uma fatia: [var first, .., var last] captura o primeiro e o último item, ignorando o meio.

Isso é conciso para sequências em que somente os limites importam, como ao validar que uma rota começa e termina em pontos conhecidos.

using System;

class Program {
    static void Main() {
        string[] route = { "A", "B", "C", "D" };
        if (route is [var start, .., var end])
            Console.WriteLine($"{start} -> {end}");
    }
}

Padrões de lista com subpadrões

Cada posição da lista pode usar qualquer padrão, inclusive padrões relacionais e lógicos. [> 0, > 0] corresponde a uma lista de dois elementos positivos.

Isso combina todo o conjunto de ferramentas de padrões na correspondência de sequências, permitindo validar o formato e o conteúdo em uma única expressão.

int[] pair = { 3, 8 };
string r = pair switch
{
    [> 0, > 0] => "both positive",
    [_, _] => "mixed",
    _ => "wrong size"
};
System.Console.WriteLine(r);

Aninhando tuplas e listas

Padrões de tupla e de lista podem ser aninhados uns nos outros e dentro de padrões de propriedade. Uma posição de tupla pode conter um padrão de lista, e vice-versa.

Isso permite comparar dados estruturados complexos, como uma sequência rotulada, em uma única expressão em vez de várias verificações aninhadas.

using System;

class Program {
    static void Main() {
        (string, int[]) record = ("primes", new[]{ 2, 3 });
        string r = record switch {
            ("primes", [2, ..]) => "starts with 2",
            _ => "other"
        };
        Console.WriteLine(r);
    }
}

Requisitos dos padrões de lista

Padrões de lista funcionam com qualquer tipo que seja contável e indexável: ele precisa ter uma propriedade Length ou Count e um indexador. Vetores, List<T> e cadeias de caracteres atendem a esses requisitos.

A captura de fatia também exige um método de fatia ou um indexador de intervalo. A maioria das coleções integradas oferece ambos por padrão.

string s = "cat";
bool isCat = s is ['c', 'a', 't'];
System.Console.WriteLine(isCat);

Verificação rápida

Teste sua compreensão dos padrões de lista e tupla.

Recapitulação

Padrões de tupla correspondem a vários valores entre parênteses; padrões de lista correspondem ao formato de uma sequência entre colchetes, usando .. como uma fatia que pode capturar o meio por meio de var.

As posições aceitam qualquer subpadrão e podem ser aninhadas livremente. Padrões de lista precisam de um tipo contável e indexável. Agora você domina todo o conjunto de ferramentas de padrões do C#.

Perguntas Frequentes

A aula “Padrões de listas e tuplas” é grátis?

Sim — o texto completo de “Padrões de listas e tuplas” é 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 “Padrões de listas e tuplas”?

Desestruture coleções. 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 4 de 4.

Quanto tempo leva a aula “Padrões de listas e tuplas”?

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