Compartir a través de

Tutorial: Uso de C# para hacer coincidir datos con patrones

En este tutorial se explica cómo usar la coincidencia de patrones para inspeccionar los datos en C#. Puede escribir pequeñas cantidades de código y, a continuación, compilar y ejecutar ese código. El tutorial contiene una serie de lecciones que exploran diferentes tipos de patrones admitidos por C#. Estas lecciones le enseñan los aspectos básicos del lenguaje C#.

En este tutorial, usted hará lo siguiente:

  • Inicie un espacio de código de GitHub con un entorno de desarrollo de C#.
  • Pruebe los datos para los valores discretos.
  • Hacer coincidir los datos de enumeración con el valor.
  • Cree coincidencias exhaustivas mediante switch expresiones.
  • Emparejar tipos usando patrones de tipo.

Prerrequisitos

Debe tener una de las siguientes opciones:

Igualar un valor

En los tutoriales anteriores se demostraron los tipos integrados y los tipos que se definen como tuplas o registros. Puede comprobar las instancias de estos tipos con un patrón. Si una instancia coincide con un patrón determina las acciones que realiza el programa. En los ejemplos siguientes, verá ? después de los nombres de tipo. Este símbolo permite que el valor de este tipo sea NULL (por ejemplo, bool? puede ser true, falseo null). Para obtener más información, consulte Tipos de valor anulable. Comencemos a explorar cómo puede usar patrones.

Abra una ventana del explorador en Espacios de código de GitHub. Cree un nuevo espacio de código a partir de la plantilla de .NET. Si completó otros tutoriales de esta serie, puede abrir ese espacio de código.

  1. Cuando se cargue el espacio de código, cree un archivo en la carpeta tutorials denominada patterns.cs.

  2. Abra su nuevo archivo.

  3. Todos los ejemplos de este tutorial usan la entrada de texto que representa una serie de transacciones bancarias como entrada de valores separados por comas (CSV). En cada una de las muestras, puede hacer coincidir el registro con un patrón mediante una expresión is o switch. En este primer ejemplo se divide cada línea del , carácter y, a continuación, se compara el primer campo de cadena con el valor "DEPOSIT" o "WITHDRAWAL" mediante una is expresión. Cuando coincide, el importe de la transacción se agrega o deduce del saldo de la cuenta actual. Para ver que funciona, agregue el código siguiente a patterns.cs:

    string bankRecords = """
    DEPOSIT,   10000, Initial balance
    DEPOSIT,     500, regular deposit
    WITHDRAWAL, 1000, rent
    DEPOSIT,    2000, freelance payment
    WITHDRAWAL,  300, groceries
    DEPOSIT,     700, gift from friend
    WITHDRAWAL,  150, utility bill
    DEPOSIT,    1200, tax refund
    WITHDRAWAL,  500, car maintenance
    DEPOSIT,     400, cashback reward
    WITHDRAWAL,  250, dining out
    DEPOSIT,    3000, bonus payment
    WITHDRAWAL,  800, loan repayment
    DEPOSIT,     600, stock dividends
    WITHDRAWAL,  100, subscription fee
    DEPOSIT,    1500, side hustle income
    WITHDRAWAL,  200, fuel expenses
    DEPOSIT,     900, refund from store
    WITHDRAWAL,  350, shopping
    DEPOSIT,    2500, project milestone payment
    WITHDRAWAL,  400, entertainment
    """;

double currentBalance = 0.0;
var reader = new StringReader(bankRecords);

string? line;
while ((line = reader.ReadLine()) is not null)
{
    if (string.IsNullOrWhiteSpace(line)) continue;
    // Split the line based on comma delimiter and trim each part
    string[] parts = line.Split(',');

    string? transactionType = parts[0]?.Trim();
    if (double.TryParse(parts[1].Trim(), out double amount))
    {
        // Update the balance based on transaction type
        if (transactionType?.ToUpper() is "DEPOSIT")
            currentBalance += amount;
        else if (transactionType?.ToUpper() is "WITHDRAWAL")
            currentBalance -= amount;

        Console.WriteLine($"{line.Trim()} => Parsed Amount: {amount}, New Balance: {currentBalance}");
    }
}

  4. A continuación, escriba el texto siguiente en la ventana del terminal:

    cd tutorials
dotnet patterns.cs

  5. Examine la salida. Puede ver que cada línea se procesa comparando el valor del texto en el primer campo.

De forma similar, podría construir el ejemplo anterior mediante el == operador para probar que dos string valores son iguales. Comparar una variable con una constante es uno de los bloques básicos para la coincidencia de patrones. Vamos a explorar más de los bloques de construcción que forman parte de la coincidencia de patrones.

Coincidencias de enum

Otro uso común para la coincidencia de patrones es la coincidencia en los valores de un enum tipo. En el ejemplo siguiente se procesan los registros de entrada para crear una tupla donde el primer valor es un enum valor que anota un depósito o una retirada. El segundo valor es el valor de la transacción.

  1. Agregue el código siguiente al final del archivo de origen. Define la TransactionType enumeración:

    public enum TransactionType
{
    Deposit,
    Withdrawal,
    Invalid
}

  2. Agregue una función para analizar una transacción bancaria en una tupla que contenga el tipo de transacción y el valor de la transacción. Agregue el siguiente código antes de la declaración de la enumeración TransactionType:

    static IEnumerable<(TransactionType type, double amount)> TransactionRecords(string inputText)
{
    var reader = new StringReader(inputText);
    string? line;
    while ((line = reader.ReadLine()) is not null)
    {
        string[] parts = line.Split(',');

        string? transactionType = parts[0]?.Trim();
        if (double.TryParse(parts[1].Trim(), out double amount))
        {
            // Update the balance based on transaction type
            if (transactionType?.ToUpper() is "DEPOSIT")
                yield return (TransactionType.Deposit, amount);
            else if (transactionType?.ToUpper() is "WITHDRAWAL")
                yield return (TransactionType.Withdrawal, amount);
        }
        else {
        yield return (TransactionType.Invalid, 0.0);
        }
    }
}

  3. Agregue un nuevo bucle para procesar los datos de transacción mediante la enumeración TransactionType que declaró.

    currentBalance = 0.0;

foreach (var transaction in TransactionRecords(bankRecords))
{
    if (transaction.type == TransactionType.Deposit)
        currentBalance += transaction.amount;
    else if (transaction.type == TransactionType.Withdrawal)
        currentBalance -= transaction.amount;
    Console.WriteLine($"{transaction.type} => Parsed Amount: {transaction.amount}, New Balance: {currentBalance}");
}

En el ejemplo anterior también se usa una if instrucción para comprobar el valor de una enum expresión. Otra forma de coincidencia de patrones usa una switch expresión. Vamos a explorar esa sintaxis y cómo se puede usar.

Coincidencias exhaustivas con switch

Una serie de if instrucciones puede probar una serie de condiciones. Pero el compilador no puede saber si una serie de if instrucciones son exhaustivas o si las if condiciones posteriores se subsumen en condiciones anteriores. Exhaustivo significa que una de las if cláusulas o else de la serie de pruebas controla todas las entradas posibles. Si una serie de if instrucciones es exhaustiva, cada entrada posible satisface al menos una cláusula if o else. La subsumpción significa que no se puede acceder a una cláusula posterior if o else porque las cláusulas anteriores if o else coinciden con todas las entradas posibles. Por ejemplo, en el código de ejemplo siguiente, una cláusula nunca coincide:

int n = GetNumber();

if (n < 20)
    Console.WriteLine("n is less than 20");
else if (n < 10)
    Console.WriteLine("n is less than 10"); // unreachable
else
    Console.WriteLine("n is greater than 20");

La else if cláusula nunca coincide porque cada número menor que 10 también es menor que 20. La switch expresión garantiza que se cumplen ambas características, lo que produce menos errores en las aplicaciones. Vamos a probarlo y veamos qué pasa.

  1. Copie el código siguiente. Reemplaza las dos if instrucciones en tu foreach bucle por la expresión switch que has copiado.

    currentBalance += transaction switch
{
    (TransactionType.Deposit, var amount) => amount,
    (TransactionType.Withdrawal, var amount) => -amount,
    _ => 0.0,
};

  2. Escriba dotnet patterns.cs en la ventana de terminal para ejecutar el nuevo ejemplo.

    Al ejecutar el código, verá que funciona igual.

  3. Para demostrar la subsumpción, reordene las ramas del interruptor como se muestra en el siguiente fragmento de código.

    currentBalance += transaction switch
{
    (TransactionType.Deposit, var amount) => amount,
    _ => 0.0,
    (TransactionType.Withdrawal, var amount) => -amount,
};

    Después de reordenar los brazos de conmutador, escriba dotnet patterns.cs en la ventana del terminal. El compilador emite un error porque el brazo con _ coincide con cada valor. Como resultado, ese brazo final con TransactionType.Withdrawal nunca se ejecuta. El compilador le indica que algo está mal en el código.

    El compilador emite una advertencia si la expresión probada en una switch expresión podría contener valores que no coinciden con ningún brazo de conmutador. Si algunos valores podrían no coincidir con ninguna condición, la switch expresión no es exhaustiva. El compilador también emite una advertencia si algunos valores de la entrada no coinciden con ninguno de los brazos switch.

  4. Quite la línea con _ => 0.0,, de modo que los valores no válidos no coincidan.

  5. Escriba dotnet patterns.cs para ver los resultados.

    El compilador emite una advertencia. Los datos de prueba son válidos, por lo que el programa funciona. Sin embargo, los datos no válidos provocarían un error en tiempo de ejecución.

Patrones de tipo

Para finalizar este tutorial, explore otro bloque de construcción para la coincidencia de patrones: el patrón de tipo. Un patrón de tipo prueba una expresión en tiempo de ejecución para ver si es el tipo especificado. Puede usar una prueba de tipo con una is expresión o una switch expresión. Modifique el ejemplo actual de dos maneras. En primer lugar, construya, en lugar de una tupla, los tipos de registro Deposit y Withdrawal que representan las transacciones.

  1. Agregue las siguientes declaraciones al final del archivo de código:

    public record Deposit(double Amount, string description);
public record Withdrawal(double Amount, string description);

  2. Agregue este método justo antes de la declaración de la TransactionType enumeración. Analiza el texto y devuelve una serie de registros:

    static IEnumerable<object?> TransactionRecordType(string inputText)
{
    var reader = new StringReader(inputText);
    string? line;
    while ((line = reader.ReadLine()) is not null)
    {
        string[] parts = line.Split(',');

        string? transactionType = parts[0]?.Trim();
        if (double.TryParse(parts[1].Trim(), out double amount))
        {
            // Update the balance based on transaction type
            if (transactionType?.ToUpper() is "DEPOSIT")
                yield return new Deposit(amount, parts[2]);
            else if (transactionType?.ToUpper() is "WITHDRAWAL")
                yield return new Withdrawal(amount, parts[2]);
        }
        yield return default;
    }
}

  3. Agregue el código siguiente después del último foreach bucle:

    currentBalance = 0.0;

foreach (var transaction in TransactionRecordType(bankRecords))
{
    currentBalance += transaction switch
    {
        Deposit d => d.Amount,
        Withdrawal w => -w.Amount,
        _ => 0.0,
    };
    Console.WriteLine($" {transaction} => New Balance: {currentBalance}");
}

  4. Escriba dotnet patterns.cs en la ventana de terminal para ver los resultados. Esta versión final prueba la entrada contra un tipo.

La coincidencia de patrones proporciona un vocabulario para comparar una expresión con las características. Los patrones pueden incluir el tipo de la expresión, los valores de los tipos, los valores de propiedad y las combinaciones de ellas. Comparar expresiones con un patrón puede ser más claro que varias comparaciones de if. Ha explorado algunos de los patrones que puede usar para hacer coincidir expresiones. Hay muchas más maneras de usar la coincidencia de patrones en las aplicaciones. A medida que explore, puede obtener más información sobre la coincidencia de patrones en C# en los siguientes artículos:

Limpieza de recursos

GitHub elimina automáticamente Codespace después de 30 días de inactividad. Ha completado todos los tutoriales de esta serie. Para eliminar codespace ahora, abra una ventana del explorador y vaya a Codespaces. Debería ver una lista de sus codespaces en la ventana. Seleccione los tres puntos (...) de la entrada del espacio de código del tutorial de aprendizaje y seleccione Eliminar.

Contenido relacionado

  • Last updated on