Declaración, constante y var patrones

Un patrón se aplica a una expresión de entrada. C# evalúa la expresión y, a continuación, el patrón prueba o captura el valor resultante. Las declaraciones, las constantes y los patrones var responden a tres preguntas prácticas:

• Patrón de declaración: ¿La expresión dio como resultado un valor no nulo de un tipo compatible en tiempo de ejecución? Si es así, declare una variable para ese valor.
• Patrón constante: ¿La expresión produjo un valor constante específico?
• var patrón: ¿Qué valor produjo la expresión? Captúralo sin comprobar antes su tipo o su valor.

Prueba y captura un tipo con un patrón de declaración

Un patrón de declaración consta de un tipo y una designación. El tipo especifica qué tipo de tiempo de ejecución se va a probar. La designación declara la variable que recibe el valor coincidente.

En el ejemplo siguiente se recibe un object, por lo que la expresión puede generar muchos tipos diferentes. El patrón de declaración permite que la rama coincidente use una cantidad decimal sin una prueba de tipo independiente y una conversión:

static void PrintPrice(object value)
{
    if (value is decimal amount)
    {
        Console.WriteLine($"Price: {amount:C}");
    }
}

En value is decimal amount:

• value es la expresión de entrada. C# lo evalúa primero.
• decimal es el tipo probado. El patrón coincide cuando el valor evaluado no es NULL y su tipo de tiempo de ejecución es compatible con decimal.
• amount es la designación. Cuando el patrón coincide, declara amount y asigna el valor decimal a él.

El compilador realiza un seguimiento de si una variable local recibe un valor antes de que el código lo lea. Este seguimiento se denomina asignación definitiva. Dentro del if bloque, el compilador sabe que amount se asignó porque el bloque solo se ejecuta cuando el patrón coincide. El compilador genera un error si el código intenta acceder amount fuera del if bloque. Si value no es un decimal valor, la variable amount no se asigna a un valor.

Elija un patrón de declaración cuando la rama coincidente necesite usar el resultado como tipo probado. Combina la comprobación, la conversión y la declaración de la variable, lo que evita repetir la expresión o escribir una conversión aparte.

También puede usar patrones de declaración cuando una expresión podría generar varios tipos útiles:

static string FormatSensorValue(object reading) =>
    reading switch
    {
        int count => $"Count: {count}",
        double temperature => $"Temperature: {temperature:F1}°C",
        string message => $"Message: {message}",
        _ => "Unsupported reading"
    };

Cada rama declara una variable del tipo correspondiente porque el resultado necesita el comportamiento de formateo de ese tipo. Un patrón de declaración coincide solo cuando el valor evaluado no es NULL y ya tiene un tipo en tiempo de ejecución compatible con el tipo probado a través de las conversiones permitidas para los patrones. null no tiene tipo en tiempo de ejecución con el que pueda coincidir el patrón. El patrón tampoco ejecuta operadores de conversión definidos por el usuario: es una prueba de tipo y captura, no una solicitud para convertir el valor a otro tipo. Para obtener las reglas de compatibilidad completas, consulte Patrones de declaración y tipo.

Coincidencia de un valor específico con un patrón constante

Un patrón constante comprueba si una expresión genera una constante determinada, como un número, una cadena, un booleano, un miembro de enumeración, un valor declarado const o null.

Los patrones constantes se ajustan a una expresión switch cuando varios valores conocidos generan un resultado diferente:

static string GetCommandMessage(Command command) =>
    command switch
    {
        Command.Start => "Starting",
        Command.Stop => "Stopping",
        Command.Pause => "Pausing",
        _ => "Unknown command"
    };

Command es una enumeración, un tipo que define un conjunto de constantes con nombre. Command.Start, Command.Stop y Command.Pause son sus miembros del tipo enum, por lo que cada rama de switch usa un patrón constante para comprobar un valor con nombre del comando.

Elija este formulario cuando el comando pueda tener varios significados discretos. Los brazos modificadores mantienen los valores y sus resultados juntos. Para una comparación simple de igualdad, una instrucción if, como if (command == Command.Start), suele ser más fácil de leer.

La comparación de patrones con constantes usa las reglas de igualdad integradas del lenguaje en lugar de un operador == definido por el usuario. Para obtener la igualdad detallada y las reglas de conversión, consulte la referencia de patrón constante.

El null patrón constante es útil para una comprobación de null confiable:

static bool HasText(string? text) => text is not null;

Elija is null o is not null cuando compruebe el estado NULL. Estos patrones no invocan un operador de igualdad definido por el usuario, incluso cuando el tipo de la expresión sobrecarga ==.

Capturar un resultado para una guarda con un patrón var

Un var patrón coincide con cada resultado, incluido null, y declara una variable cuyo tipo es el tipo de tiempo de compilación de la expresión de entrada. Puede capturar un valor calculado mientras que otro patrón ya coincide con un objeto :

static string GetDeliveryMessage(object delivery) =>
    delivery switch
    {
        ExpressDelivery express
            when EstimateDays(express) is var days && days <= 2
                => $"Arrives in {days} day{(days == 1 ? "" : "s")}",
        ExpressDelivery => "Express delivery for your location takes more than two days",
        _ => "Standard delivery"
    };

static int EstimateDays(ExpressDelivery delivery) =>
    delivery.MilesAway <= 500 ? 1 :
    delivery.MilesAway <= 1_000 ? 2 : 3;

record ExpressDelivery(int MilesAway);

El patrón ExpressDelivery express de declaración captura primero el objeto de entrega como express. La llamada al método EstimateDays(express) es la expresión de entrada del patrón var. C# evalúa esa llamada al método y var days captura la estimación resultante como days sin probar su tipo o valor. La estimación puede ser de uno o dos días cuando la protección se realiza correctamente. El resultado de la rama necesita el valor capturado para informar del número real de días.

No se puede declarar una variable local normal entre un patrón switch-arm y su when protección. Al llamar EstimateDays(express) de nuevo en el resultado, se repetiría el cálculo. Elija este var formulario de patrón cuando el código ya coincida y tanto la protección como el resultado necesitan un valor intermedio calculado.

Si no necesita el valor capturado, use el patrón _de descarte en lugar de declarar una variable.

Consulte también

• Información general sobre la coincidencia de patrones
• Patrones de tipo
• Los descartes y el patrón de descarte.
• Referencia de patrones de declaración y tipos.
• Referencia de patrón constante.
• var referencia de patrón.