Pattern matching (ampliado considerablemente en las versiones recientes de C#) te permite probar la forma, tipo y propiedades de un valor de manera concisa, y extraer datos — haciendo que la lógica condicional compleja sea mucho más clara que cadenas anidadas de if-else. Se utiliza con expresiones switch, is, y más.
// 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");
El operador is con un patrón de tipo prueba el tipo y captura el valor (tipado) en un paso — más claro que una verificación y casting separados.
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
};
Las expresiones switch soportan patrones ricos: patrones de tipo, condiciones (when), y patrones de propiedades ({ Length: > 10 } — coincidiendo en las propiedades de un objeto) — expresando ramificaciones complejas de manera 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
Pattern matching es una característica importante y cada vez más central del C# moderno — ha sido ampliada considerablemente a lo largo de las versiones recientes, transformando cómo C# maneja la lógica condicional y la verificación de tipos, por lo que comprenderla es valioso para escribir y leer código C# actual.
Su valor central es expresar lógica condicional compleja de manera concisa y legible: en lugar de cadenas anidadas de if-else con verificaciones de tipo separadas, castings y accesos a propiedades, pattern matching te permite probar el tipo, condiciones, propiedades y estructura de un valor — y extraer datos — en expresiones limpias y declarativas (especialmente con expresiones switch).
La amplitud de patrones — patrones de tipo (probar y capturar tipos en un paso a través de is), patrones de propiedades (coincidir en propiedades de objetos), patrones relacional y lógicos (< 100 and > 0, not), y patrones de lista/posicionales — cubre un amplio rango de lógica de ramificación elegantemente.
Esto refleja la evolución del C# moderno hacia código más funcional y expresivo, y pattern matching aparece extensamente en bases de código actuales (especialmente con expresiones switch y records).
Comprender los diversos patrones y cómo usarlos (con is, expresiones switch, cláusulas when) es importante para escribir C# moderno conciso y legible y para leer código que utiliza estas características.
Ya que pattern matching reemplaza lógica condicional verbosa con expresiones limpias y declarativas — mejorando la legibilidad y reduciendo errores — y ya que es una característica definitoria del C# moderno que continúa expandiéndose, dominarlo es conocimiento valioso y frecuentemente aplicado que distingue C# moderno fluido de estilos más antiguos y verbosos, y es un tema cada vez más común en entrevistas.