0Pricing
C# Academy · Lección

Patrones de tipos y propiedades

Haga coincidencias por forma y miembros

Patrones de tipos y propiedades es una lección gratuita de C# Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C# Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C# Academy incluye 4 lecciones en total.

El patrón de tipo

Un patrón de tipo coincide cuando la entrada es una instancia de un tipo determinado. Escrito simplemente como el nombre del tipo en una rama switch, comprueba el tipo en tiempo de ejecución del valor.

Esto sustituye las cadenas engorrosas de comprobaciones is y conversiones por una comprobación limpia en una sola expresión que además restringe el tipo automáticamente.

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

Patrones de declaración

Un patrón de declaración añade un nombre de variable después del tipo: string s. Cuando coincide, la entrada se convierte y se asigna a esa variable.

A continuación, puede usar la variable tipada en el lado derecho de la rama y acceder a los miembros específicos de ese tipo sin realizar otra conversión.

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

Un switch de tipos ejecutable

Los patrones de tipo son perfectos para procesar datos heterogéneos, como al analizar valores de una matriz de object.

Aquí, cada elemento coincide según su tipo en tiempo de ejecución y se da formato a los elementos según corresponda. La variable asignada conserva el tipo restringido en la expresión 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));
    }
}

El patrón de propiedades

Un patrón de propiedades inspecciona los miembros de un objeto mediante llaves: { Property: value }. Coincide cuando cada propiedad indicada satisface su patrón anidado.

Esto permite ramificar directamente según la forma y el contenido de un objeto, sin escribir comparaciones manuales de sus miembros.

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);

Varias propiedades

Puede comprobar varias propiedades a la vez separándolas mediante comas dentro de las llaves. Todas deben coincidir para que se ejecute la rama.

Esto expresa con claridad condiciones compuestas, como buscar un objeto que tenga tanto un estado como un recuento específico.

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 tipos y propiedades

Los patrones de tipo y de propiedades se pueden combinar: escriba el tipo y, a continuación, un bloque de propiedades entre llaves. La rama solo coincide si la entrada es de ese tipo y sus propiedades coinciden.

Esto resulta muy útil al trabajar con referencias a clases base o interfaces cuando desea ramificar a la vez según los subtipos concretos y su estado.

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)));
}

Patrones de propiedades anidados

Los patrones de propiedades pueden anidarse. Si una propiedad es a su vez un objeto, puede buscar sus miembros mediante otro bloque entre llaves.

Por ejemplo, { Address: { City: "Paris" } } profundiza dos niveles en una sola expresión. Esto evita cadenas de acceso mediante puntos propensas a producir errores por 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);

Acceso ampliado a propiedades

Desde C# 10 puede usar una ruta con puntos dentro de un patrón de propiedades: { Address.City: "Paris" }. Es una abreviatura de las llaves anidadas.

Esto convierte las comprobaciones profundas en una sola línea legible y, al mismo tiempo, gestiona de forma segura los valores intermedios durante la coincidencia.

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 la coincidencia completa

Puede asignar una variable al valor completo que coincide añadiendo un nombre después del patrón de propiedades: { Age: > 18 } adult.

La variable adult hace referencia al objeto completo dentro de la rama, lo que permite usarlo después de confirmar que sus propiedades superan la prueba.

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);
    }
}

Gestión de valores nulos

Un patrón de propiedades nunca coincide con null, porque no hay ningún objeto que inspeccionar. Por eso, { } (llaves vacías) coincide con cualquier valor que no sea nulo.

Esto hace que not null y { } sean expresiones habituales y útiles para comprobar valores nulos, y garantiza que las ramas basadas en propiedades omitan de forma segura las entradas nulas.

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

Por qué los patrones son mejores que las conversiones

Antes de los patrones, la ramificación basada en tipos implicaba comprobaciones is seguidas de conversiones y comprobaciones de valores nulos. Los patrones de tipo y de propiedades integran todo eso en una sola expresión.

El compilador también realiza un seguimiento de la exhaustividad y la accesibilidad, y detecta ramas inactivas y casos que faltan, algo que las cadenas de if escritas manualmente ignorarían silenciosamente.

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

Comprobación rápida

Compruebe cuánto entiende los patrones de tipo y de propiedades.

Repaso

Los patrones de tipo coinciden según el tipo en tiempo de ejecución y pueden asignar una variable tipada. Los patrones de propiedades inspeccionan miembros mediante { Prop: pattern }, admiten anidamiento y rutas con puntos, y nunca coinciden con valores nulos.

Combínelos para ramificar según la forma y el estado. A continuación, trataremos los patrones relacionales y lógicos.

Preguntas frecuentes

¿La lección «Patrones de tipos y propiedades» es gratis?

Sí — el texto completo de «Patrones de tipos y propiedades» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C# Academy, actualiza a CoddyKit PRO. El curso de C# Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Patrones de tipos y propiedades»?

Haga coincidencias por forma y miembros Practicas C# Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar C# Academy?

No se requiere experiencia previa. C# Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Patrones de tipos y propiedades»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de C# Academy?

Sí. Cada lección de C# Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Expresiones switch
  2. Patrones de tipos y propiedades
  3. Patrones relacionales y lógicos
  4. Patrones de listas y tuplas
← Volver a C# Academy