Translate

miércoles, 11 de enero de 2023

Pattern matching: las expresiones is y switch, y los operadores and, or y not en C#


Las siguientes expresiones e instrucciones de C# admiten pattern matching:

  • la expresión is 
  • la sentencia switch 
  • y la expresión switch 

En esas construcciones, se puede hacer coincidir una expresión de entrada con cualquiera de los siguientes patrones:

  • Patrón de declaración: para verificar el tipo de tiempo de ejecución de una expresión y, si una coincidencia tiene éxito, asignar un resultado de expresión a una variable declarada.
  • Patrón de tipo: para comprobar el tipo de tiempo de ejecución de una expresión. 
  • Patrón constante: para probar si el resultado de una expresión es igual a una constante especificada.
  • Patrones relacionales: para comparar el resultado de una expresión con una constante especificada. 
  • Patrones lógicos: para probar si una expresión coincide con una combinación lógica de patrones. 
  • Patrón de propiedad: para probar si las propiedades o campos de una expresión coinciden con patrones anidados.
  • Patrón posicional: para deconstruir un resultado de expresión y probar si los valores resultantes coinciden con patrones anidados.
  • patrón var: para hacer coincidir cualquier expresión y asignar su resultado a una variable declarada.
  • Patrón de descarte: para que coincida con cualquier expresión.
  • Patrones de lista: para probar si los elementos de secuencia coinciden con los patrones anidados correspondientes. 
Los patrones lógicos, de propiedad, posicionales y de lista son patrones recursivos. Es decir, pueden contener patrones anidados.

Patrones de tipo y declaración

Se utiliza patrones de declaración y tipo para verificar si el tipo de tiempo de ejecución de una expresión es compatible con un tipo dado. Con un patrón de declaración, también se puede declarar una nueva variable local. Cuando un patrón de declaración coincide con una expresión, a esa variable se le asigna un resultado de expresión convertida, como muestra el siguiente ejemplo:

object greeting = "Hello, World!";
if (greeting is string message)
{
    Console.WriteLine(message.ToLower());  // output: hello, world!
}

Un patrón de declaración con tipo T coincide con una expresión cuando el resultado de una expresión no es nulo y cualquiera de las siguientes condiciones es verdadera:

  • El tipo de tiempo de ejecución de un resultado de expresión es T.
  • El tipo de tiempo de ejecución de un resultado de expresión se deriva del tipo T, implementa la interfaz T o existe otra conversión de referencia implícita a T. El siguiente ejemplo muestra dos casos en los que esta condición sean verdadera:

var numbers = new int[] { 10, 20, 30 };
Console.WriteLine(GetSourceLabel(numbers));  // output: 1

var letters = new List<char> { 'a', 'b', 'c', 'd' };
Console.WriteLine(GetSourceLabel(letters));  // output: 2

static int GetSourceLabel<T>(IEnumerable<T> source) => source switch
{
    Array array => 1,
    ICollection<T> collection => 2,
    _ => 3,
};

En el ejemplo anterior, en la primera llamada al método GetSourceLabel, el primer patrón coincide con un valor de argumento porque el tipo de tiempo de ejecución del argumento int[] se deriva del tipo Array. En la segunda llamada al método GetSourceLabel, el tipo List<T> en tiempo de ejecución del argumento no se deriva del tipo Array pero implementa la interfaz ICollection<T>.

  • El tipo de tiempo de ejecución de un resultado de expresión es un tipo de valor que acepta valores NULL con el tipo T subyacente.
  • Existe una conversión boxing o unboxing del tipo de tiempo de ejecución de un resultado de expresión al tipo T.
El siguiente ejemplo demuestra las dos últimas condiciones:

int? xNullable = 7;
int y = 23;
object yBoxed = y;
if (xNullable is int a && yBoxed is int b)
{
    Console.WriteLine(a + b);  // output: 30
}

Si desea verificar solo el tipo de una expresión, puede usar un descarte _ en lugar del nombre de una variable, como muestra el siguiente ejemplo:

public abstract class Vehicle {}
public class Car : Vehicle {}
public class Truck : Vehicle {}

public static class TollCalculator
{
    public static decimal CalculateToll(this Vehicle vehicle) => vehicle switch
    {
        Car _ => 2.00m,
        Truck _ => 7.50m,
        null => throw new ArgumentNullException(nameof(vehicle)),
        _ => throw new ArgumentException("Unknown type of a vehicle", nameof(vehicle)),
    };
}

A partir de C# 9.0, para ello puede utilizar un patrón de tipo, como muestra el siguiente ejemplo:

public static decimal CalculateToll(this Vehicle vehicle) => vehicle switch
{
    Car => 2.00m,
    Truck => 7.50m,
    null => throw new ArgumentNullException(nameof(vehicle)),
    _ => throw new ArgumentException("Unknown type of a vehicle", nameof(vehicle)),
};


Al igual que un patrón de declaración, un patrón de tipo coincide con una expresión cuando el resultado de una expresión no es nulo y su tipo de tiempo de ejecución satisface cualquiera de las condiciones enumeradas anteriormente.

Para verificar si no es nulo, puede usar un patrón constante nulo negado, como muestra el siguiente ejemplo:

if (input is not null)
{
    // ...
}

Bueno, hasta acá con la declaración, en post posteriores seguire con los demas puntos. 


Labels: , ,