0Pricing
C# Academy · Aula

Padrões de tipo e propriedade

Faça correspondência com base na forma e nos membros.

Padrões de tipo e propriedade é 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 padrão de tipo

Um padrão de tipo corresponde quando a entrada é uma instância de determinado tipo. Escrito apenas como o nome do tipo em um braço de seleção, ele verifica o tipo do valor em tempo de execução.

Isso substitui cadeias complicadas de is e conversões por uma verificação limpa em uma única expressão, que também refina o tipo para si.

object o = "hello";
string kind = o switch
{
    int    => "number",
    string => "text",
    _      => "unknown"
};
System.Console.WriteLine(kind);

Padrões de declaração

Um padrão de declaração adiciona um nome de variável depois do tipo: string s. Quando corresponde, a entrada é convertida e associada a essa variável.

Então pode usar a variável tipada no lado direito do braço, acessando membros específicos desse tipo sem uma conversão adicional.

object o = "coddy";
string result = o switch
{
    string s => $"len {s.Length}",
    int n    => $"value {n}",
    _        => "other"
};
System.Console.WriteLine(result);

Uma seleção de tipo executável

Os padrões de tipo são perfeitos para processar dados heterogêneos, como analisar valores de uma matriz de object.

Aqui, cada elemento é comparado pelo seu tipo em tempo de execução e formatado de acordo com ele. A variável associada leva o tipo refinado para dentro da expressão de resultado.

using System;

class Program {
    static string Describe(object o) => o switch {
        int i    => $"int {i}",
        double d => $"double {d}",
        string s => $"string '{s}'",
        _        => "?"
    };
    static void Main() {
        foreach (var x in new object[]{ 1, 2.5, "hi" })
            Console.WriteLine(Describe(x));
    }
}

O padrão de propriedade

Um padrão de propriedade inspeciona os membros de um objeto usando chaves: { Property: value }. Ele corresponde quando cada propriedade listada satisfaz seu padrão aninhado.

Isso permite ramificar diretamente com base na estrutura e no conteúdo de um objeto, sem escrever comparações manuais de membros.

record Person(string Name, int Age);

var p = new Person("Ada", 30);
string stage = p switch
{
    { Age: < 18 } => "minor",
    { Age: >= 65 } => "senior",
    _ => "adult"
};
System.Console.WriteLine(stage);

Várias propriedades

Pode testar várias propriedades ao mesmo tempo, separando-as por vírgulas dentro das chaves. Todas devem corresponder para que o braço seja executado.

Isso expressa claramente condições compostas, como corresponder a um objeto que tenha tanto um estado quanto uma contagem específica.

record Order(string Status, int Items);

var order = new Order("Open", 0);
string msg = order switch
{
    { Status: "Open", Items: 0 } => "empty cart",
    { Status: "Open" } => "shopping",
    _ => "closed"
};
System.Console.WriteLine(msg);

Combinar tipo e propriedade

Os padrões de tipo e de propriedade podem ser combinados: escreva o tipo e, em seguida, um bloco de propriedades entre chaves. O braço só corresponde se a entrada for desse tipo e suas propriedades também corresponderem.

Isso é poderoso ao lidar com referências à classe base ou interfaces nas quais deseja ramificar simultaneamente com base nos subtipos concretos e no estado deles.

using System;

abstract record Shape;
record Circle(double R) : Shape;
record Square(double Side) : Shape;

class Program {
    static string Big(Shape s) => s switch {
        Circle { R: > 10 } => "big circle",
        Square { Side: > 10 } => "big square",
        _ => "small"
    };
    static void Main() => Console.WriteLine(Big(new Circle(12)));
}

Padrões de propriedade aninhados

Os padrões de propriedade podem ser aninhados. Se uma propriedade for ela própria um objeto, pode corresponder aos seus membros usando outro bloco entre chaves.

Por exemplo, { Address: { City: "Paris" } } percorre dois níveis de profundidade em uma única expressão. Isso evita cadeias de acesso por pontos sujeitas a valores nulos.

record Address(string City);
record User(string Name, Address Address);

var u = new User("Lin", new Address("Paris"));
bool inParis = u is { Address: { City: "Paris" } };
System.Console.WriteLine(inParis);

Acesso estendido a propriedades

Desde o C# 10, pode usar um caminho separado por pontos dentro de um padrão de propriedade: { Address.City: "Paris" }. Essa é uma forma abreviada de usar chaves aninhadas.

Isso transforma verificações profundas em uma única linha legível, mantendo o tratamento seguro dos valores intermediários durante a correspondência.

record Address(string City);
record User(string Name, Address Address);

var u = new User("Lin", new Address("Rome"));
string where = u switch
{
    { Address.City: "Paris" } => "FR",
    { Address.City: "Rome" }  => "IT",
    _ => "??"
};
System.Console.WriteLine(where);

Capturar toda a correspondência

Pode associar uma variável ao valor correspondente inteiro adicionando um nome depois do padrão de propriedade: { Age: > 18 } adult.

A variável adult passa então a referir-se ao objeto completo dentro do braço, permitindo usá-lo depois de confirmar que suas propriedades passaram pela verificação.

using System;

record Person(string Name, int Age);

class Program {
    static void Main() {
        Person p = new("Sam", 40);
        string r = p switch {
            { Age: >= 18 } adult => $"{adult.Name} can vote",
            _ => "too young"
        };
        Console.WriteLine(r);
    }
}

Tratamento de valores nulos

Um padrão de propriedade nunca corresponde a null, porque não há objeto para inspecionar. Portanto, { } (chaves vazias) corresponde a qualquer valor não nulo.

Isso torna not null e { } expressões idiomáticas úteis para verificar valores nulos e garante que os braços baseados em propriedades ignorem entradas nulas com segurança.

string? maybe = null;
string state = maybe switch
{
    null => "missing",
    { Length: 0 } => "empty",
    _ => "has text"
};
System.Console.WriteLine(state);

Por que os padrões são melhores que as conversões

Antes dos padrões, a ramificação baseada em tipos significava verificações com is seguidas de conversões e guardas contra valores nulos. Os padrões de tipo e de propriedade reúnem tudo isso em uma única expressão.

O compilador também acompanha a exaustividade e a possibilidade de alcance, identificando braços inativos e casos ausentes que cadeias de condicionais escritas manualmente ignorariam silenciosamente.

object o = 42;
// Old: if (o is int) { int n = (int)o; ... }
// New:
if (o is int n) System.Console.WriteLine(n + 1);

Verificação rápida

Teste sua compreensão sobre padrões de tipo e de propriedade.

Recapitulação

Os padrões de tipo correspondem pelo tipo em tempo de execução e podem associar uma variável tipada. Os padrões de propriedade inspecionam membros com { Prop: pattern }, aceitam aninhamento e caminhos separados por pontos, e nunca correspondem a valores nulos.

Combine-os para ramificar com base tanto na estrutura quanto no estado. Em seguida, abordaremos os padrões relacionais e lógicos.

Perguntas Frequentes

A aula “Padrões de tipo e propriedade” é grátis?

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

Faça correspondência com base na forma e nos membros. 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 “Padrões de tipo e propriedade”?

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

  1. Expressões switch
  2. Padrões de tipo e propriedade
  3. Padrões relacionais e lógicos
  4. Padrões de listas e tuplas
← Voltar para C# Academy