Compartir a través de

11 Patrones y coincidencia de patrones

11.1 General

Un patrón es una forma sintáctica que se puede usar con el is operador (§12.14.12), en un switch_statement (§13.8.3) y en un switch_expression (§12.11) para expresar la forma de datos con los que se van a comparar los datos entrantes. Los patrones pueden ser recursivos, de modo que las partes de los datos se puedan comparar con subprocesos.

Un patrón se prueba con un valor en varios contextos:

  • En una instrucción switch, el patrón de una etiqueta case se prueba con la expresión de la instrucción switch.
  • En un operador is-pattern , el patrón del lado derecho se prueba con la expresión de la izquierda.
  • En una expresión switch, el patrón de un switch_expression_arm se prueba con la expresión en el lado izquierdo de switch-expression.
  • En contextos anidados, el subproceso se prueba con valores recuperados de propiedades, campos o indexados de otros valores de entrada, según el formulario de patrón.

El valor con el que se prueba un patrón se denomina valor de entrada de patrón.

11.2 Formularios de patrón

11.2.1 General

Un patrón puede tener una de las formas siguientes:

pattern
    : declaration_pattern
    | constant_pattern
    | var_pattern
    | positional_pattern
    | property_pattern
    | discard_pattern
    ;

Algunos patronespueden dar lugar a la declaración de una variable local.

Cada formulario de patrón define el conjunto de tipos para los valores de entrada a los que se puede aplicar el patrón. Un patrón P es aplicable a un tipo T si T está entre los tipos cuyos valores puede coincidir el patrón. Es un error en tiempo de compilación si un patrón P aparece en un programa para que coincida con un valor de entrada de patrón (§11.1) de tipo T si P no es aplicable a T.

Ejemplo: el ejemplo siguiente genera un error en tiempo de compilación porque el tipo de tiempo de compilación de v es TextReader. Una variable de tipo TextReader nunca puede tener un valor compatible con string:

TextReader v = Console.In; // compile-time type of 'v' is 'TextReader'
if (v is string) // compile-time error
{
    // code assuming v is a string
}

Sin embargo, lo siguiente no genera un error en tiempo de compilación porque el tipo de tiempo de compilación de v es object. Una variable de tipo object podría tener un valor compatible con la referencia con string:

object v = Console.In;
if (v is string s)
{
    // code assuming v is a string
}

ejemplo final

Cada formulario de patrón define el conjunto de valores para los que el patrón coincide con el valor en tiempo de ejecución.

No se especifica el orden de evaluación de operaciones y efectos secundarios durante la coincidencia de patrones (llamadas a , accesos a Deconstructpropiedades e invocaciones de métodos en System.ITuple).

11.2.2 Patrón de declaración

Se usa un declaration_pattern para probar que un valor tiene un tipo determinado y, si la prueba se realiza correctamente, para proporcionar opcionalmente el valor en una variable de ese tipo.

declaration_pattern
    : type simple_designation
    ;
simple_designation
    : discard_designation
    | single_variable_designation
    ;
discard_designation
    : '_'
    ;
single_variable_designation
    : identifier
    ;

Un simple_designation con el token _ se considerará un discard_designation en lugar de un single_variable_designation.

El tipo en tiempo de ejecución del valor se prueba con el tipo del patrón mediante las mismas reglas especificadas en el operador is-type (§12.14.12.12.1). Si la prueba se realiza correctamente, el patrón coincide con ese valor. Es un error en tiempo de compilación si el tipo es un tipo de valor que acepta valores NULL (§8.3.12) o un tipo de referencia que acepta valores NULL (§8.9.3). Este formulario de patrón nunca coincide con un null valor.

Nota: La expresión e is T is-type y el patrón e is T _ de declaración son equivalentes cuando T no es un tipo que acepta valores NULL. nota final

Dado un valor de entrada de patrón (§11.1) e, si el simple_designation es discard_designation, denota un descarte (§9.2.9.2) y el valor de e no está enlazado a nada. (Aunque una variable declarada con el nombre _ puede estar en el ámbito en ese momento, esa variable con nombre no se ve en este contexto). De lo contrario, si el simple_designation es single_variable_designation, se introduce una variable local (§9.2.9) del tipo especificado denominado por el identificador especificado. A esa variable local se le asigna el valor del valor de entrada del patrón cuando el patrón coincide con el valor.

Ciertas combinaciones de tipo estático del valor de entrada de patrón y el tipo especificado se consideran incompatibles y producen un error en tiempo de compilación. Se dice que un valor de tipo E estático es compatible con el patrón T si existe una conversión de identidad, una conversión de referencia implícita o explícita, una conversión de conversión boxing o una conversión unboxing de E a T, o si o ET es un tipo abierto (§8.4.3). Un patrón de declaración que asigna un nombre a un tipo T es aplicable ael patrón .

Nota: La compatibilidad con tipos abiertos puede ser más útil al comprobar tipos que pueden ser tipos de estructura o clase, y se debe evitar la conversión boxing. nota final

Ejemplo: el patrón de declaración es útil para realizar pruebas de tipos en tiempo de ejecución de tipos de referencia y reemplaza la expresión

var v = expr as Type;
if (v != null) { /* code using v */ }

con un poco más conciso

if (expr is Type v) { /* code using v */ }

ejemplo final

Ejemplo: El patrón de declaración se puede usar para probar valores de tipos que aceptan valores NULL: un valor de tipo Nullable<T> (o un boxed T) coincide con un patrón T2 id de tipo si el valor no es NULL y T2 es T, o algún tipo base o interfaz de T. Por ejemplo, en el fragmento de código

int? x = 3;
if (x is int v) { /* code using v */ }

La condición de la if instrucción está true en tiempo de ejecución y la variable v contiene el valor 3 de tipo int dentro del bloque. Después del bloque, la variable v está en el ámbito, pero no está asignada definitivamente. ejemplo final

11.2.3 Patrón constante

Un constant_pattern se usa para probar el valor de un valor de entrada de patrón (§11.1) con el valor constante especificado.

constant_pattern
    : constant_expression
    ;

Un patrón P de constante se aplica a un tipo T si hay una conversión implícita de la expresión constante de P al tipo T.

Para un patrón Pconstante, su valor convertido es

  • si el tipo del valor de entrada del patrón es un tipo entero o un tipo de enumeración, el valor constante del patrón se convierte en ese tipo; de otra manera
  • si el tipo del valor de entrada del patrón es la versión que acepta valores NULL de un tipo entero o un tipo de enumeración, el valor constante del patrón se convierte en su tipo subyacente; de otra manera
  • el valor del valor constante del patrón.

Dado un valor de entrada de patrón e y un patrón P constante con valor convertido v,

  • si e tiene tipo entero o tipo de enumeración, o una forma que acepta valores NULL de uno de ellos, y v tiene un tipo entero, el patrón P coincide con el valor e si el resultado de la expresión e == v es true; de lo contrario,
  • el patrón Pcoincide con el valor e si object.Equals(e, v) devuelve true.

Ejemplo: la switch instrucción del método siguiente usa cinco patrones constantes en sus etiquetas de mayúsculas y minúsculas.

static decimal GetGroupTicketPrice(int visitorCount)
{
    switch (visitorCount) 
    {
        case 1: return 12.0m;
        case 2: return 20.0m;
        case 3: return 27.0m;
        case 4: return 32.0m;
        case 0: return 0.0m;
        default: throw new ArgumentException(...);
    }
}

ejemplo final

Patrón var 11.2.4

Un var_patterncoincide con cada valor. Es decir, una operación de coincidencia de patrones con una var_pattern siempre se realiza correctamente.

Un var_pattern es aplicable a cada tipo.

var_pattern
    : 'var' designation
    ;
designation
    : simple_designation
    | tuple_designation
    ;
tuple_designation
    : '(' designations? ')'
    ;
designations
    : designation (',' designation)*
    ;

Dado un valor de entrada de patrón (§11.1) e, si la designación es discard_designation, denota un descarte (§9.2.9.2) y el valor de e no está enlazado a nada. (Aunque una variable declarada con ese nombre puede estar en el ámbito en ese momento, esa variable con nombre no se ve en este contexto). De lo contrario, si la designación es single_variable_designation, en tiempo de ejecución, el valor de e está enlazado a una variable local recién introducida (§9.2.9) de ese nombre cuyo tipo es el tipo estático de e y el valor de entrada del patrón se asigna a esa variable local.

Se trata de un error si el nombre var se enlazaría a un tipo en el que se usa un var_pattern .

Si la designación es un tuple_designation, el patrón es equivalente a un positional_pattern (§11.2.5) de la designación de formulario(var, ... ) donde las designacionesson las que se encuentran dentro de la tuple_designation. Por ejemplo, el patrón var (x, (y, z)) es equivalente a (var x, (var y, var z)).

11.2.5 Patrón posicional

Un positional_pattern comprueba que el valor de entrada no nulles , invoca un método adecuado Deconstruct (§12.7) y realiza una coincidencia de patrones adicional en los valores resultantes. También admite una sintaxis de patrón similar a la tupla (sin el tipo proporcionado) cuando el tipo del valor de entrada es el mismo que el tipo que contiene Deconstruct, o si el tipo del valor de entrada es un tipo de tupla, o si el tipo del valor de entrada es object o System.ITuple y el tipo en tiempo de ejecución de la expresión implementa System.ITuple.

positional_pattern
    : type? '(' subpatterns? ')' property_subpattern? simple_designation?
    ;
subpatterns
    : subpattern (',' subpattern)*
    ;
subpattern
    : pattern
    | identifier ':' pattern
    ;

Dada una coincidencia de un valor de entrada con lossubpatrones) de tipo( de patrón, se selecciona un método buscando en tipo las declaraciones accesibles de Deconstruct y seleccionando uno entre ellos con las mismas reglas que para la declaración de deconstrucción. Se trata de un error si un positional_pattern omite el tipo, tiene un único subpatrón sin un identificador, no tiene property_subpattern y no tiene simple_designation. Esto desambigua entre un constant_pattern entre paréntesis y un positional_pattern. Para extraer los valores que deben coincidir con los patrones de la lista,

  • Si se omite el tipo y el tipo de la expresión de entrada es un tipo de tupla, el número de subpatrones será el mismo que la cardinalidad de la tupla. Cada elemento de tupla coincide con el subpatrón correspondiente y la coincidencia se realiza correctamente si todas estas se realizan correctamente. Si algún subpatrón tiene un identificador, se denominará un elemento de tupla en la posición correspondiente del tipo de tupla.
  • De lo contrario, si existe un adecuado Deconstruct como miembro de tipo, se trata de un error en tiempo de compilación si el tipo del valor de entrada no es compatible con el patrón con el tipo. En tiempo de ejecución, el valor de entrada se prueba con el tipo . Si se produce un error, se produce un error en la coincidencia de patrones posicionales. Si se ejecuta correctamente, el valor de entrada se convierte en este tipo y Deconstruct se invoca con variables generadas por el compilador nuevas para recibir los parámetros de salida. Cada valor que se recibió coincide con el subpatrón correspondiente y la coincidencia se realiza correctamente si todas estas se realizan correctamente. Si algún subpatrón tiene un identificador, se asignará un nombre a un parámetro en la posición correspondiente de Deconstruct.
  • De lo contrario, si se omite el tipo y el valor de entrada es de tipo object o de algún tipo al que se puede convertir System.ITuple mediante una conversión de referencia implícita y no aparece ningún identificador entre los subpatrones, la coincidencia usa System.ITuple.
  • De lo contrario, el patrón es un error en tiempo de compilación.

El orden en el que se coinciden los subpatrones en tiempo de ejecución no está especificado y es posible que una coincidencia con errores no intente coincidir con todos los subpatrones.

Ejemplo: aquí, deconstruimos un resultado de expresión y comparamos los valores resultantes con los patrones anidados correspondientes:

static string Classify(Point point) => point switch
{
    (0, 0) => "Origin",
    (1, 0) => "positive X basis end",
    (0, 1) => "positive Y basis end",
    _ => "Just a point",
};

public readonly struct Point
{
    public int X { get; }
    public int Y { get; }
    public Point(int x, int y) => (X, Y) = (x, y);
    public void Deconstruct(out int x, out int y) => (x, y) = (X, Y);
}

ejemplo final

Ejemplo: los nombres de los elementos de tupla y los parámetros Deconstruct se pueden usar en un patrón posicional, como se indica a continuación:

var numbers = new List<int> { 10, 20, 30 };
if (SumAndCount(numbers) is (Sum: var sum, Count: var count))
{
    Console.WriteLine($"Sum of [{string.Join(" ", numbers)}] is {sum}");
}

static (double Sum, int Count) SumAndCount(IEnumerable<int> numbers)
{
    int sum = 0;
    int count = 0;
    foreach (int number in numbers)
    {
        sum += number;
        count++;
    }
    return (sum, count);
}

La salida generada es

Sum of [10 20 30] is 60

ejemplo final

11.2.6 Patrón de propiedad

Un property_pattern comprueba que el valor de entrada no nulles y coincide recursivamente con los valores extraídos por el uso de propiedades o campos accesibles.

property_pattern
    : type? property_subpattern simple_designation?
    ;
property_subpattern
    : '{' '}'
    | '{' subpatterns ','? '}'
    ;

Se trata de un error si algún subpatrón de un property_pattern no contiene un identificador.

Es un error en tiempo de compilación si el tipo es un tipo de valor que acepta valores NULL (§8.3.12) o un tipo de referencia que acepta valores NULL (§8.9.3).

Nota: Un patrón de comprobación de valores NULL sale de un patrón de propiedad trivial. Para comprobar si la cadena s no es NULL, puede escribir cualquiera de los siguientes formularios:

#nullable enable
string s = "abc";
if (s is object o) ...  // o is of type object
if (s is string x1) ... // x1 is of type string
if (s is {} x2) ...     // x2 is of type string
if (s is {}) ...

nota final Dada una coincidencia de una expresión e con el tipo{ de patrónproperty_pattern_list}, se trata de un error en tiempo de compilación si la expresión e no es compatible con el tipo T designado por tipo. Si el tipo está ausente, se supone que el tipo es el tipo estático de e. Cada uno de los identificadores que aparecen en el lado izquierdo de su property_pattern_list designará una propiedad o campo legible accesible de T. Si la simple_designation de la property_pattern está presente, declara una variable de patrón de tipo T.

En tiempo de ejecución, la expresión se prueba en T. Si se produce un error, se produce un error en la coincidencia del patrón de propiedad y el resultado es false. Si se ejecuta correctamente, cada property_subpattern campo o propiedad se lee y su valor coincide con su patrón correspondiente. El resultado de toda la coincidencia es false solo si el resultado de cualquiera de estos es false. No se especifica el orden en el que se coinciden los subpatrones y es posible que una coincidencia con errores no pruebe todos los subpatrones en tiempo de ejecución. Si la coincidencia se realiza correctamente y el simple_designation del property_pattern es un single_variable_designation, a la variable declarada se le asigna el valor coincidente.

El property_pattern se puede usar para establecer coincidencias de patrones con tipos anónimos.

Ejemplo:

var o = ...;
if (o is string { Length: 5 } s) ...

ejemplo final

Ejemplo: se puede agregar una comprobación de tipos en tiempo de ejecución y una declaración de variable a un patrón de propiedad, como se indica a continuación:

Console.WriteLine(TakeFive("Hello, world!"));  // output: Hello
Console.WriteLine(TakeFive("Hi!"));            // output: Hi!
Console.WriteLine(TakeFive(new[] { '1', '2', '3', '4', '5', '6', '7' }));  // output: 12345
Console.WriteLine(TakeFive(new[] { 'a', 'b', 'c' }));  // output: abc

static string TakeFive(object input) => input switch
{
    string { Length: >= 5 } s => s.Substring(0, 5),
    string s => s,
    ICollection<char> { Count: >= 5 } symbols => new string(symbols.Take(5).ToArray()),
    ICollection<char> symbols => new string(symbols.ToArray()),
    null => throw new ArgumentNullException(nameof(input)),
    _ => throw new ArgumentException("Not supported input type."),
};

La salida generada es

Hello
Hi!
12345
abc

ejemplo final

11.2.7 Patrón de descarte

Cada expresión coincide con el patrón de descarte, lo que da como resultado el valor de la expresión que se va a descartar.

discard_pattern
    : '_'
    ;

Se trata de un error en tiempo de compilación para usar un patrón de descarte en un relational_expression del formulario relational_expressionispatrón o como patrón de un switch_label.

Nota: En esos casos, para que coincida con cualquier expresión, use un var_pattern con un descarte var _. nota final

Ejemplo:

Console.WriteLine(GetDiscountInPercent(DayOfWeek.Friday));
Console.WriteLine(GetDiscountInPercent(null));
Console.WriteLine(GetDiscountInPercent((DayOfWeek)10));

static decimal GetDiscountInPercent(DayOfWeek? dayOfWeek) => dayOfWeek switch
{
    DayOfWeek.Monday => 0.5m,
    DayOfWeek.Tuesday => 12.5m,
    DayOfWeek.Wednesday => 7.5m,
    DayOfWeek.Thursday => 12.5m,
    DayOfWeek.Friday => 5.0m,
    DayOfWeek.Saturday => 2.5m,
    DayOfWeek.Sunday => 2.0m,
    _ => 0.0m,
};

La salida generada es

5.0
0.0
0.0

En este caso, se usa un patrón de descarte para controlar null y cualquier valor entero que no tenga el miembro correspondiente de la DayOfWeek enumeración. Esto garantiza que la switch expresión controla todos los valores de entrada posibles. ejemplo final

Subsumpción de patrón 11.3

En una instrucción switch, se trata de un error si el patrón de un caso está subsumado por el conjunto anterior de casos no supervisados (§13.8.3). Informalmente, esto significa que cualquiera de los valores de entrada habría sido coincidente con uno de los casos anteriores. Las reglas siguientes definen cuándo un conjunto de patrones subsume un patrón determinado:

Un patrón Pcoincidiría con una constante K si la especificación del comportamiento en tiempo de ejecución de ese patrón es que P coincide con K.

Un conjunto de patrones Qsubsumes un patrón P si alguna de las condiciones siguientes contiene:

11.4 Exhaustiva de patrones

Informalmente, un conjunto de patrones es exhaustivo para un tipo si, para cada valor posible de ese tipo distinto de NULL, se aplica algún patrón del conjunto. Las reglas siguientes definen cuándo un conjunto de patrones es exhaustivo para un tipo:

Un conjunto de patrones Q es exhaustivo para un tipo T si alguna de las condiciones siguientes contiene:

  1. T es un tipo entero o de enumeración, o una versión que acepta valores NULL de uno de ellos, y para cada valor posible del Ttipo subyacente que no acepta valores NULL, algún patrón de Q coincidiría con ese valor; o
  2. Algún patrón de Q es un patrón var; o
  3. Algún patrón de Q es un patrón de declaración para el tipo Dy hay una conversión de identidad, una conversión de referencia implícita o una conversión boxing de T a D.

Ejemplo:

static void M(byte b)
{
    switch (b) {
        case 0: case 1: case 2: ... // handle every specific value of byte
            break;
        // error: the pattern 'byte other' is subsumed by the (exhaustive)
        // previous cases
        case byte other: 
            break;
    }
}

ejemplo final

  • Last updated on