Correspondência de padrões (greatly expanded in recent C# versions) permite testar a forma, tipo e propriedades de um valor de forma concisa e extrair dados — tornando a lógica condicional complexa muito mais limpa do que cadeias aninhadas de if-else. É usada com expressões switch, is e muito mais.
// type pattern — test type AND capture in one step
if (obj is string s)
Console.WriteLine(s.Length); // s is typed as string here (no separate cast)
if (obj is int n and > 0) // combine: type + condition
Console.WriteLine("positive int");
O operador is com um padrão de tipo testa o tipo e captura o valor (tipado) em uma única etapa — mais limpo do que uma verificação e conversão separadas.
string Describe(object obj) => obj switch
{
int n when n > 0 => "positive int", // type + condition (when)
int => "non-positive int",
string { Length: > 10 } => "long string", // property pattern
null => "null",
_ => "other", // default
};
As expressões switch suportam padrões ricos: padrões de tipo, condições (when) e padrões de propriedade ({ Length: > 10 } — correspondência nas propriedades de um objeto) — expressando ramificações complexas de forma concisa.
// property pattern — match on properties
var discount = customer switch
{
{ IsVip: true, Orders: > 100 } => 0.2, // multiple property conditions
{ Orders: > 50 } => 0.1,
_ => 0.0,
};
// relational + logical patterns (C# 9)
string Size(int n) => n switch
{
< 0 => "negative",
0 => "zero",
> 0 and < 100 => "small", // relational (< >) + logical (and/or/not)
_ => "large",
};
var (x, y) = point; // positional/deconstruction
int[] arr = { 1, 2, 3 };
if (arr is [1, .., 3]) { } // list pattern (C# 11) — starts with 1, ends with 3
Correspondência de padrões é um recurso importante e cada vez mais central do C# moderno — foi muito expandida em versões recentes, transformando como o C# lida com lógica condicional e verificação de tipos, portanto compreendê-la é valioso para escrever e ler código C# atual.
Seu valor principal é expressar lógica condicional complexa de forma concisa e legível: em vez de cadeias aninhadas de if-else com verificações de tipo, conversões e acessos de propriedade separados, correspondência de padrões permite testar o tipo, condições, propriedades e estrutura de um valor — e extrair dados — em expressões limpas e declarativas (especialmente com expressões switch).
A amplitude de padrões — padrões de tipo (testar e capturar tipos em uma única etapa via is), padrões de propriedade (correspondência nas propriedades do objeto), padrões relacionais e lógicos (< 100 and > 0, not) e padrões de lista/posicionais — cobre uma ampla gama de lógica de ramificação elegantemente.
Isso reflete a evolução do C# moderno em direção a código mais funcional e expressivo, e correspondência de padrões aparece extensivamente em bases de código atuais (especialmente com expressões switch e records).
Compreender os vários padrões e como usá-los (com is, expressões switch, cláusulas when) é importante para escrever C# moderno conciso e legível e para ler código que usa esses recursos.
Como correspondência de padrões substitui lógica condicional verbosa por expressões limpas e declarativas — melhorando a legibilidade e reduzindo bugs — e como é um recurso definidor do C# moderno que continua se expandindo, dominá-lo é conhecimento valioso e frequentemente aplicado que distingue C# moderno fluente de estilos mais antigos e verbosos, e é um tópico cada vez mais comum em entrevistas.
Uma biblioteca de perguntas de entrevista de TI com respostas detalhadas — de Júnior a Sênior.
Doar