La coincidencia de patrones en C# es una característica poderosa que se introdujo en C# 7.0 y desde entonces se ha ampliado en versiones posteriores. Permite a los desarrolladores escribir un código más conciso y expresivo al manejar declaraciones condicionales, verificación de tipos y descomposición de objetos.
Las expresiones de coincidencia de patrones proporcionan una manera flexible e intuitiva de hacer coincidir valores con patrones y ejecutar bloques de código correspondientes. En este artículo, exploraremos las complejidades de las expresiones de coincidencia de patrones en C#, incluyendo sintaxis, casos de uso y ejemplos de código. Al final del artículo, también exploraremos un poco sobre la Biblioteca de Generación de PDF IronPDF de Iron Software para generar un documento PDF sobre la marcha en aplicaciones C#.
La coincidencia de patrones en el código C# presenta una gran cantidad de ventajas:
La coincidencia de patrones es compatible con las siguientes expresiones:
is expresiónswitch declaracionesswitch expresionesLos patrones siguientes pueden usarse para coincidir con las construcciones:
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!
}Dim greeting As Object = "Iron Software is Awesome!"
Dim tempVar As Boolean = TypeOf greeting Is String
Dim message As String = If(tempVar, DirectCast(greeting, String), Nothing)
If tempVar Then
Console.WriteLine(message.ToLower()) ' output: iron software is awesome!
End IfAquí, 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 subsecuentes.
Cuando se cumplen cualquiera de las siguientes condiciones, el Patrón de Declaración es válido:
T.T, implementa la interfaz T o puede ser convertido implícitamente a T.T.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
}Dim nullableX? As Integer = 8
Dim y As Integer = 45
Dim boxedy As Object = y
Dim tempVar As Boolean = TypeOf boxedy Is Integer
Dim b As Integer = If(tempVar, DirectCast(boxedy, Integer), Nothing)
Dim tempVar2 As Boolean = TypeOf nullableX Is Integer
Dim a As Integer = If(tempVar2, CInt(nullableX), Nothing)
If tempVar2 AndAlso tempVar Then
Console.WriteLine(a + b) ' output: 53
End IfAquí, 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 necesite verificar el tipo de expresión sin declarar una nueva variable, puede utilizar el descarte _, como se ve en el siguiente ejemplo:
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)),
};'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'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 un 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 IsNot Nothing Then
' ...
End IfEsta negación asegura que inputVal no sea nulo antes de proceder con operaciones posteriores.
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.
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)),
};Dim tempVar As Decimal
Select Case visitorCount
Case 1
tempVar = 2.0D
Case 2
tempVar = 10.0D
Case 3
tempVar = 25.0D
Case 4
tempVar = 60.0D
Case 0
tempVar = 0.0D
Case Else
'INSTANT VB TODO TASK: Throw expressions are not converted by Instant VB:
'ORIGINAL LINE: tempVar = throw new ArgumentException(string.Format("Not supported number of visitors: {0}", visitorCount), nameof(visitorCount));
tempVar = throw New ArgumentException($"Not supported number of visitors: {visitorCount}", NameOf(visitorCount))
End Select
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'public static decimal GetGroupTicketPrice(int visitorCount)
'{
' Return tempVar;
'}Aquí, los patrones constantes verifican si visitorCount coincide con alguno de los valores constantes especificados y devuelven los precios de los boletos correspondientes.
En un patrón constante, puedes emplear varios tipos de expresiones constantes, como:
true o false).null.Una expresión de tipo Span<char> o ReadOnlySpan<char> puede coincidir con cadenas constantes.
Para verificar null, utilice un patrón constante así:
if (inputVal is null)
{
return;
}If inputVal Is Nothing Then
Return
End IfAquí, el patrón asegura que inputVal sea nulo antes de proceder con operaciones posteriores.
También puedes utilizar un patrón constante nulo negado para asegurar valores no nulos:
if (inputVal is not null)
{
// ...
}If inputVal IsNot Nothing Then
' ...
End IfEste patrón verifica que inputVal no sea nulo, permitiendo que se realicen operaciones subsecuentes 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.
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
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'static string Classify(double measurement) => measurement switch
'{
' < -4.0 => "Too low",
' > 10.0 => "Too high",
' double.NaN => "Unknown",
' _ => "Acceptable",
'};Aquí, los patrones relacionales comparan el measurement contra umbrales específicos para determinar su clasificación.
La parte derecha de un patrón relacional debe ser una expresión constante, que puede ser de un tipo entero, de punto flotante, char, o enum. Los operadores <, >, <=, >= se pueden usar en el lado izquierdo.
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
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'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.
El patrón de descarte, denotado por _, sirve para coincidir con 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(Nothing)) ' output: 0.0
Console.WriteLine(GetDiscountInPercent(CType(10, DayOfWeek))) ' output: 0.0
Dim tempVar As Decimal
Select Case dayOfWeek
Case DayOfWeek.Monday
tempVar = 0.5D
Case DayOfWeek.Tuesday
tempVar = 12.5D
Case DayOfWeek.Wednesday
tempVar = 7.5D
Case DayOfWeek.Thursday
tempVar = 12.5D
Case DayOfWeek.Friday
tempVar = 5.0D
Case DayOfWeek.Saturday
tempVar = 2.5D
Case DayOfWeek.Sunday
tempVar = 2.0D
Case Else
tempVar = 0.0D
End Select
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'static decimal GetDiscountInPercent(System.Nullable(Of DayOfWeek) dayOfWeek)
'{
' Return tempVar;
'}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 descarte 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 descarte, como var _, para coincidir con cualquier expresión. Sin embargo, un patrón de descarte 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.
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.
not patrón)El patrón de negación, representado por not, coincide con una expresión cuando el patrón negado no coincide con la expresión. Esto es particularmente útil para verificar si una expresión no es nula, como se demuestra a continuación:
if (input is not null)
{
// ...
}If input IsNot Nothing Then
' ...
End IfAquí, el bloque de código se ejecuta si input no es nulo.
and pattern)El patrón conjuntivo, utilizando la palabra clave and, coincide con una expresión cuando ambos patrones coinciden con la expresión. Esto permite combinar múltiples condiciones, como lo ilustra el siguiente ejemplo:
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
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'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",
'};En este ejemplo, el measurement se clasifica basado en su rango de valores.
or pattern)El patrón disyuntivo, utilizando la palabra clave or, coincide con una expresión cuando cualquiera de los patrones coincide con la expresión. Esto permite manejar múltiples condiciones posibles, como se muestra a continuación:
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
Dim tempVar As String
Select Case [date].Month
Case 3, 4, 5
tempVar = "spring"
Case 6, 7, 8
tempVar = "summer"
Case 9, 10, 11
tempVar = "autumn"
Case 12, 1, 2
tempVar = "winter"
Case Else
'INSTANT VB TODO TASK: Throw expressions are not converted by Instant VB:
'ORIGINAL LINE: tempVar = throw new ArgumentOutOfRangeException(nameof(date), string.Format("Date with unexpected month: {0}.", date.Month));
tempVar = throw New ArgumentOutOfRangeException(NameOf([date]), $"Date with unexpected month: {[date].Month}.")
End Select
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'static string GetCalendarSeason(DateTime @date)
'{
' Return tempVar;
'}Aquí, la temporada del calendario se determina en función del mes de la fecha proporcionada.
Estos combinadores de patrones pueden ser utilizados repetidamente para crear condiciones de coincidencia más complejas y precisas, mejorando la flexibilidad y legibilidad de tu código.
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 };Shared Function IsConferenceDay(ByVal [date] As DateTime) As Boolean
'INSTANT VB TODO TASK: The following 'is' operator pattern is not converted by Instant VB:
Return [date] is { Year: 2020, Month: 5, Day: 19 [or] 20 [or] 21 }
End FunctionAquí, 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."),
};'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'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.
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",
};'INSTANT VB WARNING: VB has no equivalent to the C# readonly struct:
'ORIGINAL LINE: public readonly struct Point
Public Structure Point
Public ReadOnly Property X() As Integer
Public ReadOnly Property Y() As Integer
Public Sub New(ByVal x As Integer, ByVal y As Integer)
'INSTANT VB TODO TASK: VB has no equivalent to the C# deconstruction assignments:
(X, Y) = (x, y)
End Sub
Public Sub Deconstruct(<System.Runtime.InteropServices.Out()> ByRef x As Integer, <System.Runtime.InteropServices.Out()> ByRef y As Integer)
'INSTANT VB TODO TASK: VB has no equivalent to the C# deconstruction assignments:
(x, y) = (X, Y)
End Sub
End Structure
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'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 };Shared Function IsAnyEndOnXAxis(ByVal segment As Segment) As Boolean
'INSTANT VB TODO TASK: The following 'is' operator pattern is not converted by Instant VB:
Return segment is { Start.Y: 0 } [or] { [End].Y: 0 }
End FunctionEsta 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.
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();
}Shared Function IsAcceptable(ByVal id As Integer, ByVal absLimit As Integer) As Boolean
Dim tempVar As Boolean = TypeOf SimulateDataFetch(id) Is var
Dim results = If(tempVar, CType(SimulateDataFetch(id), var), Nothing)
Return tempVar AndAlso results.Min() >= -absLimit AndAlso results.Max() <= absLimit
End Function
Shared Function SimulateDataFetch(ByVal id As Integer) As Integer()
Dim rand = New Random()
Return Enumerable.Range(start:= 0, count:= 5).Select(Function(s) rand.Next(minValue:= -10, maxValue:= 11)).ToArray()
End FunctionEn este ejemplo, SimulateDataFetch devuelve un arreglo 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 }
}'INSTANT VB TODO TASK: C# 'records' are not converted by Instant VB:
'public record Point(int X, int Y)
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'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),
'};
Shared Sub 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 }
End SubEn 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.
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 IronPdfLa imagen inferior muestra cómo instalar desde Guía de Instalación de Visual Studio.
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}."),
};
}
}Imports IronPdf
Namespace IronPatterns
Friend Class Program
Shared Sub Main()
Console.WriteLine("-----------Iron Software-------------")
Dim renderer = New ChromePdfRenderer() ' var pattern
Dim content = " <h1> Iron Software is Awesome </h1> Made with IronPDF!"
' Declaration Pattern
Dim nullableX? As Integer = 8
Dim y As Integer = 45
Dim boxedy As Object = y
content &= "<p>Declaration Pattern</p>"
Dim tempVar As Boolean = TypeOf boxedy Is Integer
Dim b As Integer = If(tempVar, DirectCast(boxedy, Integer), Nothing)
Dim tempVar2 As Boolean = TypeOf nullableX Is Integer
Dim a As Integer = If(tempVar2, CInt(nullableX), Nothing)
If tempVar2 AndAlso tempVar Then
Console.WriteLine(a + b) ' output: 53
content &= $"<p>Output: {(a + b)}</p>"
End If
' Relational patterns
content &= "<p>Relational patterns</p>"
Dim season1 = GetCalendarSeason(New DateTime(2024, 2, 25))
Console.WriteLine(season1)
content &= $"<p>2024, 2, 25: {season1}</p>"
Dim season2 = GetCalendarSeason(New DateTime(2024, 5, 25))
Console.WriteLine(season2)
content &= $"<p>2024, 5, 25: {season2}</p>"
Dim season3 = GetCalendarSeason(New DateTime(2024, 7, 25))
Console.WriteLine(season3)
content &= $"<p>2024, 7, 25: {season3}</p>"
Dim pdf = renderer.RenderHtmlAsPdf(content)
pdf.SaveAs("output.pdf") ' Saves our PdfDocument object as a PDF
End Sub
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
' 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}."),
' };
End Class
End Namespace
Aquí estamos utilizando la clase ChromePdfRenderer de IronPDF para guardar la cadena HTML en un documento PDF. La salida se guarda en el documento "output.pdf".
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>"Coloque la clave de licencia en el archivo appsettings.json como se muestra arriba.
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.
Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.
IronPDF es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
