C# Expresiones de Coincidencia de Patrones (Cómo Funciona para Desarrolladores)

Beneficios de la concordancia de patrones en C#

La coincidencia de patrones en el código C# presenta una gran cantidad de ventajas:

• Legibilidad mejorada: la coincidencia de patrones simplifica la lógica condicional compleja, lo que hace que su código sea más fácil de entender y seguir tanto para usted como para otros desarrolladores.
• Reducción de líneas de código: al condensar declaraciones condicionales complejas en patrones concisos, la coincidencia de patrones ayuda a simplificar su base de código, lo que genera menos líneas de código y una implementación más concisa.
• Mantenibilidad mejorada: la claridad que ofrece la coincidencia de patrones promueve un mantenimiento y una depuración del código más sencillos. Con patrones claramente delineados, se vuelve más sencillo identificar y modificar bloques lógicos específicos según sea necesario sin afectar el resto de la base de código.
• Algoritmos más expresivos: la coincidencia de patrones permite a los desarrolladores expresar algoritmos de una manera más natural e intuitiva. Al alinear las estructuras de código con paradigmas para la resolución de problemas, la coincidencia de patrones facilita la creación de algoritmos que se asemejan estrechamente a sus modelos conceptuales.

Tipos de concordancia de patrones en C#

La coincidencia de patrones es compatible con las siguientes expresiones:

• Expresión is
• Declaraciones switch
• Expresiones switch

Los patrones siguientes pueden usarse para coincidir con las construcciones:

Patrones de declaración y tipos

Los patrones de declaración y tipo son herramientas esenciales en C# para verificar la compatibilidad de tipos de tiempo de ejecución de expresiones con tipos dados. Con patrones de declaración, puedes tanto verificar la compatibilidad como declarar una nueva variable local simultáneamente. Considera el siguiente ejemplo:

object greeting = "Iron Software is Awesome!";
if (greeting is string message)
{
    Console.WriteLine(message.ToLower());  // output: iron software is awesome!
}

object greeting = "Iron Software is Awesome!";
if (greeting is string message)
{
    Console.WriteLine(message.ToLower());  // output: iron software is awesome!
}

Aquí, el patrón de declaración asegura que si la expresión greeting coincide con el tipo string, se asigna a la variable message, permitiendo operaciones posteriores.

Cuando se cumplen cualquiera de las siguientes condiciones, el Patrón de Declaración es válido:

• El tipo de tiempo de ejecución de la expresión es T.
• El tipo de tiempo de ejecución de la expresión deriva de T, implementa la interfaz T, o puede ser convertido implícitamente a T.
• El tipo de tiempo de ejecución de la expresión es un tipo de valor anulable con el tipo subyacente T.
• Existe una conversión de empaquetado o desempaquetado del tipo de tiempo de ejecución de la expresión al tipo T.

Considera el siguiente ejemplo que demuestra las condiciones anteriores:

int? nullableX = 8;
int y = 45;
object boxedy = y;
if (nullableX is int a && boxedy is int b)
{
    Console.WriteLine(a + b);  // output: 53
}

int? nullableX = 8;
int y = 45;
object boxedy = y;
if (nullableX is int a && boxedy is int b)
{
    Console.WriteLine(a + b);  // output: 53
}

Aquí, nullableX coincide con el patrón porque es un tipo de valor anulable con el tipo subyacente int, y boxedy coincide porque puede ser desempaquetado a int.

Cuando solo necesitas verificar el tipo de expresión sin declarar una nueva variable, puedes utilizar el descarte _, como se ve en el ejemplo a continuación:

public static decimal CalculateToll(Vehicle vehicle) => vehicle switch
{
    Bus _ => 4.00m,
    Motor _ => 8.50m,
    null => throw new ArgumentNullException(nameof(vehicle)),
    _ => throw new ArgumentException("Unknown type of a vehicle", nameof(vehicle)),
};

public static decimal CalculateToll(Vehicle vehicle) => vehicle switch
{
    Bus _ => 4.00m,
    Motor _ => 8.50m,
    null => throw new ArgumentNullException(nameof(vehicle)),
    _ => throw new ArgumentException("Unknown type of a vehicle", nameof(vehicle)),
};

En este fragmento, el _ sirve como marcador de posición para cualquier tipo que coincida con Vehicle.

Ambos patrones de declaración y tipo aseguran que las expresiones no sean nulas antes de la coincidencia de patrones. Puedes verificar la no nulidad utilizando un patrón constante nulo negado, como se ilustra a continuación:

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

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

Esta negación asegura que inputVal no sea nulo antes de proceder con más operaciones.

Al aprovechar patrones de declaración y tipo en tu código C#, puedes mejorar la legibilidad, reducir las líneas de código y expresar algoritmos de manera más efectiva. Estos patrones proporcionan una forma concisa y expresiva de manejar la lógica basada en tipos y mejorar la mantenibilidad de tu base de código.

Patrón constante

Los patrones constantes sirven para verificar si un resultado de expresión coincide con un valor constante específico. Considera el siguiente ejemplo:

public static decimal GetGroupTicketPrice(int visitorCount) => visitorCount switch
{
    1 => 2.0m,
    2 => 10.0m,
    3 => 25.0m,
    4 => 60.0m,
    0 => 0.0m,
    _ => throw new ArgumentException($"Not supported number of visitors: {visitorCount}", nameof(visitorCount)),
};

public static decimal GetGroupTicketPrice(int visitorCount) => visitorCount switch
{
    1 => 2.0m,
    2 => 10.0m,
    3 => 25.0m,
    4 => 60.0m,
    0 => 0.0m,
    _ => throw new ArgumentException($"Not supported number of visitors: {visitorCount}", nameof(visitorCount)),
};

Aquí, los patrones constantes verifican si visitorCount coincide con alguno de los valores constantes especificados y devuelve los precios de los boletos correspondientes.

En un patrón constante, puedes emplear varios tipos de expresiones constantes, como:

1. Literales numéricos de enteros o de punto flotante.
2. Caracteres.
3. Literales de cadena.
4. Valores booleanos (true o false).
5. Valores Enum.
6. El nombre de un campo o local declarado como constante.
7. null.

Una expresión de tipo Span<char> o ReadOnlySpan<char> puede coincidir con cadenas constantes.

Para verificar null, utiliza un patrón constante como sigue:

if (inputVal is null)
{
    return;
}

if (inputVal is null)
{
    return;
}

Aquí, el patrón asegura que inputVal sea nulo antes de proceder con más operaciones.

También puedes utilizar un patrón constante nulo negado para asegurar valores no nulos:

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

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

Este patrón verifica que inputVal no sea nulo, permitiendo así que se realicen operaciones posteriores de manera segura.

Al incorporar patrones constantes en tu código C#, puedes manejar efectivamente escenarios donde se necesiten coincidir valores constantes específicos, mejorando la claridad y mantenibilidad del código.

Patrones relacionales

Los patrones relacionales proporcionan un medio para comparar resultados de expresiones con constantes. Considera el siguiente ejemplo:

Console.WriteLine(Classify(20));  // output: Too high
Console.WriteLine(Classify(double.NaN));  // output: Unknown
Console.WriteLine(Classify(4));  // output: Acceptable

static string Classify(double measurement) => measurement switch
{
    < -4.0 => "Too low",
    > 10.0 => "Too high",
    double.NaN => "Unknown",
    _ => "Acceptable",
};

Console.WriteLine(Classify(20));  // output: Too high
Console.WriteLine(Classify(double.NaN));  // output: Unknown
Console.WriteLine(Classify(4));  // output: Acceptable

static string Classify(double measurement) => measurement switch
{
    < -4.0 => "Too low",
    > 10.0 => "Too high",
    double.NaN => "Unknown",
    _ => "Acceptable",
};

Aquí, los patrones relacionales comparan la measurement contra umbrales específicos para determinar su clasificación.

La parte derecha de un patrón relacional debe ser una expresión constante, la cual puede ser de un tipo entero, de punto flotante, char o enum. Los operadores <, >, <=, >= pueden utilizarse en la parte izquierda.

Para hacer coincidir un resultado de expresión dentro de un cierto rango, emplea un patrón conjuntivo "and", como se ilustra a continuación:

Console.WriteLine(GetCalendarSeason(new DateTime(2024, 3, 12)));  // output: spring
Console.WriteLine(GetCalendarSeason(new DateTime(2024, 7, 12)));  // output: summer
Console.WriteLine(GetCalendarSeason(new DateTime(2024, 2, 12)));  // output: winter

static string GetCalendarSeason(DateTime date) => date.Month switch
{
    >= 3 and < 6 => "spring",
    >= 6 and < 9 => "summer",
    >= 9 and < 12 => "autumn",
    12 or (>= 1 and <3) => "winter",
    _ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
};

Console.WriteLine(GetCalendarSeason(new DateTime(2024, 3, 12)));  // output: spring
Console.WriteLine(GetCalendarSeason(new DateTime(2024, 7, 12)));  // output: summer
Console.WriteLine(GetCalendarSeason(new DateTime(2024, 2, 12)));  // output: winter

static string GetCalendarSeason(DateTime date) => date.Month switch
{
    >= 3 and < 6 => "spring",
    >= 6 and < 9 => "summer",
    >= 9 and < 12 => "autumn",
    12 or (>= 1 and <3) => "winter",
    _ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
};

Este extracto describe cómo se utiliza el patrón conjuntivo "and" para determinar la temporada del calendario basado en el mes dentro de rangos específicos. También menciona que los patrones relacionales proporcionan un medio conciso y expresivo para comparar resultados de expresiones contra constantes, mejorando así la claridad y mantenibilidad del código.

Patrón de descarte

El patrón de desecho, denotado por _, sirve para coincidir cualquier expresión, incluyendo null. Toma el siguiente ejemplo:

Console.WriteLine(GetDiscountInPercent(DayOfWeek.Friday));  // output: 5.0
Console.WriteLine(GetDiscountInPercent(null));  // output: 0.0
Console.WriteLine(GetDiscountInPercent((DayOfWeek)10));  // output: 0.0

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

Console.WriteLine(GetDiscountInPercent(DayOfWeek.Friday));  // output: 5.0
Console.WriteLine(GetDiscountInPercent(null));  // output: 0.0
Console.WriteLine(GetDiscountInPercent((DayOfWeek)10));  // output: 0.0

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

En el ejemplo de patrón de desecho anterior, maneja todos los posibles valores de entrada. Todos los días de la semana son gestionados, y se proporciona un valor predeterminado. Con esto, todos los valores posibles son manejados. El patrón de desecho no puede ser utilizado como un patrón en una expresión is o una declaración switch. En tales casos, se puede usar un patrón var con un desecho, como var _, para coincidir con cualquier expresión. Sin embargo, un patrón de desecho es permisible en una expresión switch. Para más detalles, consulta la sección de patrón de Desecho de la nota de propuesta de característica.

Patrones lógicos

Los patrones lógicos en C# ofrecen poderosas herramientas para la coincidencia de patrones, incluyendo negación, conjunción y disyunción, que permiten condiciones de coincidencia más flexibles y expresivas.

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

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

Console.WriteLine(Classify(13));    // output: High
Console.WriteLine(Classify(-100));  // output: Too low
Console.WriteLine(Classify(5.7));   // output: Acceptable

static string Classify(double measurement) => measurement switch
{
    < -40.0 => "Too low",
    >= -40.0 and < 0 => "Low",
    >= 0 and < 10.0 => "Acceptable",
    >= 10.0 and < 20.0 => "High",
    >= 20.0 => "Too high",
    double.NaN => "Unknown",
};

Console.WriteLine(Classify(13));    // output: High
Console.WriteLine(Classify(-100));  // output: Too low
Console.WriteLine(Classify(5.7));   // output: Acceptable

static string Classify(double measurement) => measurement switch
{
    < -40.0 => "Too low",
    >= -40.0 and < 0 => "Low",
    >= 0 and < 10.0 => "Acceptable",
    >= 10.0 and < 20.0 => "High",
    >= 20.0 => "Too high",
    double.NaN => "Unknown",
};

Console.WriteLine(GetCalendarSeason(new DateTime(2021, 1, 19)));  // output: winter
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 10, 9)));  // output: autumn
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 5, 11)));  // output: spring

static string GetCalendarSeason(DateTime date) => date.Month switch
{
    3 or 4 or 5 => "spring",
    6 or 7 or 8 => "summer",
    9 or 10 or 11 => "autumn",
    12 or 1 or 2 => "winter",
    _ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
};

Console.WriteLine(GetCalendarSeason(new DateTime(2021, 1, 19)));  // output: winter
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 10, 9)));  // output: autumn
Console.WriteLine(GetCalendarSeason(new DateTime(2021, 5, 11)));  // output: spring

static string GetCalendarSeason(DateTime date) => date.Month switch
{
    3 or 4 or 5 => "spring",
    6 or 7 or 8 => "summer",
    9 or 10 or 11 => "autumn",
    12 or 1 or 2 => "winter",
    _ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
};

Patrón de propiedades

El patrón de propiedad permite la coincidencia de las propiedades de una expresión o campos contra patrones anidados. Un ejemplo de esto puede verse en el siguiente fragmento de código:

static bool IsConferenceDay(DateTime date) => date is { Year: 2020, Month: 5, Day: 19 or 20 or 21 };

static bool IsConferenceDay(DateTime date) => date is { Year: 2020, Month: 5, Day: 19 or 20 or 21 };

Aquí, el patrón de propiedad asegura que la fecha proporcionada corresponda a uno de los días de conferencia especificados.

También puedes incorporar una verificación de tipo de tiempo de ejecución y declaración de variables dentro de un patrón de propiedad, como se muestra a continuación:

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("Unsupported input type."),
};

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("Unsupported input type."),
};

Aquí, el patrón de propiedad se utiliza para manejar cadenas y colecciones de caracteres, asegurando un manejo adecuado basado en sus propiedades.

Patrón posicional

En C#, el patrón posicional permite descomponer un resultado de expresión y hacer coincidir los valores resultantes con patrones anidados correspondientes. Por ejemplo:

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

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

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",
};

En este ejemplo, el patrón posicional se utiliza para clasificar puntos basados en sus coordenadas.

Además, puedes referenciar propiedades anidadas o campos dentro de un patrón de propiedad, conocido como un patrón de propiedad extendido, introducido en C# 10:

static bool IsAnyEndOnXAxis(Segment segment) =>
    segment is { Start.Y: 0 } or { End.Y: 0 };

static bool IsAnyEndOnXAxis(Segment segment) =>
    segment is { Start.Y: 0 } or { End.Y: 0 };

Esta característica mejora la flexibilidad de los patrones de propiedades permitiendo el acceso directo a propiedades anidadas.

Estos patrones proporcionan mecanismos poderosos para manejar estructuras de datos complejas y mejorar la legibilidad y expresividad de tu código.

Patrón Var

El Patrón Var te permite hacer coincidir cualquier tipo. Esto puede ser particularmente útil para capturar resultados intermedios dentro de expresiones booleanas o cuando se requieren múltiples verificaciones en los safeguards de los casos switch.

Aquí tienes un ejemplo que demuestra el uso del patrón var en una expresión booleana:

static bool IsAcceptable(int id, int absLimit) =>
    SimulateDataFetch(id) is var results 
    && results.Min() >= -absLimit 
    && results.Max() <= absLimit;

static int [] SimulateDataFetch(int id)
{
    var rand = new Random();
    return Enumerable
               .Range(start: 0, count: 5)
               .Select(s => rand.Next(minValue: -10, maxValue: 11))
               .ToArray();
}

static bool IsAcceptable(int id, int absLimit) =>
    SimulateDataFetch(id) is var results 
    && results.Min() >= -absLimit 
    && results.Max() <= absLimit;

static int [] SimulateDataFetch(int id)
{
    var rand = new Random();
    return Enumerable
               .Range(start: 0, count: 5)
               .Select(s => rand.Next(minValue: -10, maxValue: 11))
               .ToArray();
}

En este ejemplo, SimulateDataFetch devuelve un array de enteros, y el patrón is var captura el resultado en la variable results, permitiendo cálculos subsecuentes basados en sus propiedades.

Además, los patrones var pueden ser utilizados dentro de expresiones o declaraciones switch para un código más conciso y legible. Aquí tienes un ejemplo usando el patrón var en los guards del caso switch:

public record Point(int X, int Y);

static Point Transform(Point point) => point switch
{
    var (x, y) when x < y => new Point(-x, y),
    var (x, y) when x > y => new Point(x, -y),
    var (x, y) => new Point(x, y),
};

static void TestTransform()
{
    Console.WriteLine(Transform(new Point(1, 2)));  // output: Point { X = -1, Y = 2 }
    Console.WriteLine(Transform(new Point(5, 2)));  // output: Point { X = 5, Y = -2 }
}

public record Point(int X, int Y);

static Point Transform(Point point) => point switch
{
    var (x, y) when x < y => new Point(-x, y),
    var (x, y) when x > y => new Point(x, -y),
    var (x, y) => new Point(x, y),
};

static void TestTransform()
{
    Console.WriteLine(Transform(new Point(1, 2)));  // output: Point { X = -1, Y = 2 }
    Console.WriteLine(Transform(new Point(5, 2)));  // output: Point { X = 5, Y = -2 }
}

En este ejemplo, el patrón var (x, y) captura las coordenadas del punto, permitiendo diferentes transformaciones basadas en sus valores.

En un patrón var, el tipo de la variable declarada se infiere del tipo de tiempo de compilación de la expresión que se está haciendo coincidir con el patrón.

El patrón var proporciona una forma conveniente de manejar varios escenarios donde el tipo específico de expresión no se conoce de antemano, mejorando la claridad y flexibilidad del código.

Presentación de la biblioteca IronPDF

IronPDF Document Rendering es una biblioteca de Iron Software que se especializa en generación de documentos PDF. Para empezar, lo primero es instalar la biblioteca desde el gestor de paquetes NuGet o desde el Gestor de Paquetes de Visual Studio.

# To install from the NuGet Package Manager Console
Install-Package IronPdf

# To install from the NuGet Package Manager Console
Install-Package IronPdf

La imagen inferior muestra cómo instalar desde Guía de Instalación de Visual Studio.

Expresiones de Coincidencia de Patrones en C# (Cómo Funciona Para Desarrolladores): Figura 1 - Instalación de IronPDF con el gestor de paquetes NuGet

En el siguiente código, veremos cómo generar un documento PDF simple:

using IronPdf;

namespace IronPatterns
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine("-----------Iron Software-------------");
            var renderer = new ChromePdfRenderer(); // var pattern
            var content = " <h1> Iron Software is Awesome </h1> Made with IronPDF!";

            // Declaration Pattern
            int? nullableX = 8;
            int y = 45;
            object boxedy = y;
            content += "<p>Declaration Pattern</p>";
            if (nullableX is int a && boxedy is int b)
            {
                Console.WriteLine(a + b); // output: 53
                content += $"<p>Output: {(a + b)}</p>";
            }

            // Relational patterns
            content += "<p>Relational patterns</p>";
            var season1 = GetCalendarSeason(new DateTime(2024, 2, 25));
            Console.WriteLine(season1);
            content += $"<p>2024, 2, 25: {season1}</p>";
            var season2 = GetCalendarSeason(new DateTime(2024, 5, 25));
            Console.WriteLine(season2);
            content += $"<p>2024, 5, 25: {season2}</p>";
            var season3 = GetCalendarSeason(new DateTime(2024, 7, 25));
            Console.WriteLine(season3);
            content += $"<p>2024, 7, 25: {season3}</p>";

            var pdf = renderer.RenderHtmlAsPdf(content);
            pdf.SaveAs("output.pdf"); // Saves our PdfDocument object as a PDF        
        }

        static string GetCalendarSeason(DateTime date) => date.Month switch
        {
            >= 3 and < 6 => "spring",
            >= 6 and < 9 => "summer",
            >= 9 and < 12 => "autumn",
            12 or (>= 1 and < 3) => "winter",
            _ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
        };
    }
}

using IronPdf;

namespace IronPatterns
{
    class Program
    {
        static void Main()
        {
            Console.WriteLine("-----------Iron Software-------------");
            var renderer = new ChromePdfRenderer(); // var pattern
            var content = " <h1> Iron Software is Awesome </h1> Made with IronPDF!";

            // Declaration Pattern
            int? nullableX = 8;
            int y = 45;
            object boxedy = y;
            content += "<p>Declaration Pattern</p>";
            if (nullableX is int a && boxedy is int b)
            {
                Console.WriteLine(a + b); // output: 53
                content += $"<p>Output: {(a + b)}</p>";
            }

            // Relational patterns
            content += "<p>Relational patterns</p>";
            var season1 = GetCalendarSeason(new DateTime(2024, 2, 25));
            Console.WriteLine(season1);
            content += $"<p>2024, 2, 25: {season1}</p>";
            var season2 = GetCalendarSeason(new DateTime(2024, 5, 25));
            Console.WriteLine(season2);
            content += $"<p>2024, 5, 25: {season2}</p>";
            var season3 = GetCalendarSeason(new DateTime(2024, 7, 25));
            Console.WriteLine(season3);
            content += $"<p>2024, 7, 25: {season3}</p>";

            var pdf = renderer.RenderHtmlAsPdf(content);
            pdf.SaveAs("output.pdf"); // Saves our PdfDocument object as a PDF        
        }

        static string GetCalendarSeason(DateTime date) => date.Month switch
        {
            >= 3 and < 6 => "spring",
            >= 6 and < 9 => "summer",
            >= 9 and < 12 => "autumn",
            12 or (>= 1 and < 3) => "winter",
            _ => throw new ArgumentOutOfRangeException(nameof(date), $"Date with unexpected month: {date.Month}."),
        };
    }
}

Licencia de prueba

IronPDF se puede usar con una licencia de prueba obtenida de la Página de Licencias de IronPDF. Proporciona un Correo Electrónico para generar una clave de licencia que se enviará a tu correo.

"IronPDF.LicenseKey": "<Your Key>"

"IronPDF.LicenseKey": "<Your Key>"

Coloca la clave de licencia en el archivo appsettings.json como se muestra arriba.

Conclusión

Las expresiones de coincidencia de patrones en C# ofrecen una forma poderosa y flexible de escribir declaraciones condicionales, comprobaciones de tipo y descomposiciones de objetos de manera concisa y legible. Al aprovechar la coincidencia de patrones, los desarrolladores pueden mejorar la claridad y mantenibilidad de su código mientras reducen el código redundante y la redundancia. Ya sea para verificación de tipos, declaraciones switch o descomposición, las expresiones de coincidencia de patrones brindan un conjunto de herramientas versátiles para abordar una amplia gama de tareas de programación en C#.

En conclusión, dominar las expresiones de coincidencia de patrones puede mejorar enormemente tus habilidades de programación en C#, permitiéndote escribir código más limpio y expresivo que sea más fácil de entender y mantener. También hemos cubierto las capacidades de Generación de HTML a PDF de IronPDF, que se pueden aprovechar para generar documentos PDF.