Pattern matching con switch en C#

using IronPdf; // Disable local disk access or cross-origin requests Installation.EnableWebSecurity = true; // Instantiate Renderer var renderer = new ChromePdfRenderer(); // Create a PDF from a HTML string using C# var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>"); // Export to a file or Stream pdf.SaveAs("output.pdf"); // Advanced Example with HTML Assets // Load external html assets: Images, CSS and JavaScript. // An optional BasePath 'C:\site\assets\' is set as the file location to load assets from var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\"); myAdvancedPdf.SaveAs("html-with-assets.pdf");

C# Switch Pattern Matching (Cómo Funciona para Desarrolladores)

Preguntas Frecuentes

¿Cómo se puede aplicar la coincidencia de patrones de switch en el procesamiento de documentos en C#?

La coincidencia de patrones de switch en C# se puede utilizar para simplificar la lógica de toma de decisiones compleja. Al integrarse con una biblioteca de PDF como IronPDF, permite a los desarrolladores gestionar las tareas de procesamiento de documentos de manera más efectiva al agilizar la lógica de decisiones y mejorar la legibilidad del código.

¿Cuáles son las ventajas de usar la coincidencia de patrones de switch sobre las declaraciones tradicionales de if-else?

La coincidencia de patrones de switch proporciona una forma más concisa y legible de manejar múltiples condiciones en comparación con las declaraciones tradicionales de if-else. Mejora la mantenibilidad del código de C#, especialmente cuando se trata de tareas complejas de procesamiento de documentos usando IronPDF.

¿Cómo facilita la coincidencia de patrones de switch la automatización de documentos PDF?

La coincidencia de patrones de switch facilita la automatización de documentos PDF al permitir a los desarrolladores construir una lógica más limpia para gestionar diversas acciones y tipos de datos de documentos. Al usarse con IronPDF, ayuda a automatizar los flujos de trabajo y agilizar los procesos de extracción de datos.

¿Puede la coincidencia de patrones de switch manejar flujos de trabajo de documentos complejos en C#?

Sí, la coincidencia de patrones de switch es adecuada para manejar flujos de trabajo de documentos complejos en C#. Simplifica la lógica necesaria para gestionar diferentes tipos de documentos y acciones, especialmente cuando se usa junto a bibliotecas robustas como IronPDF.

¿Cómo implementas la coincidencia de patrones de switch en una aplicación de procesamiento de PDF en C#?

En una aplicación de procesamiento de PDF en C#, puedes implementar la coincidencia de patrones de switch usando la declaración switch con sintaxis de coincidencia de patrones para gestionar diferentes tipos de documentos o condiciones de procesamiento. IronPDF se puede utilizar para encargarse de las tareas de manipulación concreta de PDF.

¿Qué desafíos pueden enfrentar los desarrolladores al usar la coincidencia de patrones de switch en C#?

Los desarrolladores pueden enfrentar desafíos con la coincidencia de patrones de switch al tratar con patrones dinámicos o basados en tiempo de ejecución que requieren una lógica más compleja. Sin embargo, cuando se usa correctamente con una biblioteca como IronPDF, puede mejorar significativamente la eficiencia del código.

¿Cómo contribuye la coincidencia de patrones de switch a la mantenibilidad del código?

La coincidencia de patrones de switch contribuye a la mantenibilidad del código al proporcionar una forma clara y concisa de manejar múltiples condiciones. Esto reduce la complejidad y facilita la comprensión y modificación del código, especialmente en aplicaciones a gran escala que utilizan IronPDF.

Jacob Mellor

Chatea con el equipo de ingeniería ahora

Director de Tecnología

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, ...

.NET AYUDA

Trabajar con archivos PDF en C# a menudo implica manejar diferentes tipos de documentos, acciones o fuentes de datos. Tradicionalmente, los desarrolladores podrían depender de largas cadenas if-else o declaraciones switch anidadas para gestionar varios valores de entrada y tipos o decisiones de salida. Pero con características modernas de C# como switch pattern matching, el código puede volverse mucho más elegante, legible y mantenible.

Cuando se combina con una poderosa biblioteca PDF como IronPDF, el switch pattern matching permite construir lógica más inteligente y limpia para el procesamiento de documentos. En este artículo, exploraremos cómo usar las características avanzadas de pattern matching de C#—como patrones de tipo, patrones de propiedad y patrones relacionales—junto con IronPDF para optimizar los flujos de trabajo de generación de PDF.

¿Qué es el switch pattern matching en C#?

Switch pattern matching es una característica introducida en C# 7 y continuamente mejorada en versiones posteriores. A diferencia de las declaraciones switch tradicionales que solo coinciden con valores constantes, el pattern matching permite evaluar tipos, propiedades y condiciones dentro de una sola expresión. El siguiente ejemplo muestra cómo funciona esta característica.

Ejemplo de sintaxis

switch (input)
{
    case int i when i > 0:
        Console.WriteLine("Positive integer");
        break;
    case string s:
        Console.WriteLine($"It's a string: {s}");
        break;
    default:
        Console.WriteLine("Unknown type");
        break;
}

switch (input)
{
    case int i when i > 0:
        Console.WriteLine("Positive integer");
        break;
    case string s:
        Console.WriteLine($"It's a string: {s}");
        break;
    default:
        Console.WriteLine("Unknown type");
        break;
}

Select Case input
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case int i when i > 0:
	Case Integer i [when] i > 0
		Console.WriteLine("Positive integer")
'INSTANT VB TODO TASK: The following 'case' pattern variable is not converted by Instant VB:
'ORIGINAL LINE: case string s:
	Case String s
		Console.WriteLine($"It's a string: {s}")
	Case Else
		Console.WriteLine("Unknown type")
End Select

$vbLabelText $csharpLabel

Este código utiliza patrones de tipo, operadores relacionales y un patrón constante nulo para manejar múltiples casos de manera concisa. Esta técnica mejora significativamente la legibilidad del código con una sintaxis más concisa y soporta lógica más compleja.

¿Por qué combinar la concordancia de patrones de conmutación con IronPDF?

Coincidencia de patrones de conmutación de C# (cómo funciona para desarrolladores): Figura 1 - Página de inicio de IronPDF

IronPDF es un poderoso componente .NET para generar y manipular PDFs a partir de HTML, imágenes o texto sin formato. Muchos casos de uso del mundo real implican procesar diferentes patrones de entrada: algunos documentos podrían originarse en URLs, otros en cadenas HTML, y otros en cargas de archivos.

En lugar de probar expresiones con torpes condiciones if, switch pattern matching permite soportar lógica basada en patrones de manera eficiente. Permite definir cómo responde la aplicación a diferentes tipos de objetos, constantes especificadas o incluso expresiones booleanas, utilizando la expresión de entrada misma para impulsar el flujo de trabajo.

Casos de uso comunes en IronPDF con concordancia de patrones

En el ejemplo anterior vimos cómo luce la sintaxis básica, pero ahora veamos cómo funciona en acción. Los siguientes ejemplos de código son algunas tareas del mundo real con PDF que se benefician al combinar IronPDF con el pattern matching de C#.

1. Manejo de múltiples formatos de entrada con patrones de tipos y propiedades

Supongamos que tu método acepta varios formatos de entrada: HTML, un Uri o un archivo .html local. Usando patrones de tipo, patrones de propiedad y patrones nulos, puedes distinguir estos casos sin esfuerzo.

using System;
using System.IO;
using IronPdf;
class Program
{
    static void Main()
    {
        object input = new Uri("https://example.com"); // Try changing this to: "<html><body>Hello</body></html>" or new FileInfo("sample.html")
        var renderer = new ChromePdfRenderer();
        PdfDocument pdfDoc = input switch
        {
            string html when html.StartsWith("<html>") =>
                renderer.RenderHtmlAsPdf(html),
            Uri url =>
                renderer.RenderUrlAsPdf(url.ToString()),
            FileInfo { Extension: ".html" } file =>
                renderer.RenderHtmlAsPdf(File.ReadAllText(file.FullName)),
            null => throw new ArgumentNullException("Input was null."),
            _ => throw new ArgumentException("Unsupported input type for PDF conversion.")
        };
        pdfDoc.SaveAs("example-input-types.pdf");
        Console.WriteLine("PDF created: example-input-types.pdf");
    }
}

using System;
using System.IO;
using IronPdf;
class Program
{
    static void Main()
    {
        object input = new Uri("https://example.com"); // Try changing this to: "<html><body>Hello</body></html>" or new FileInfo("sample.html")
        var renderer = new ChromePdfRenderer();
        PdfDocument pdfDoc = input switch
        {
            string html when html.StartsWith("<html>") =>
                renderer.RenderHtmlAsPdf(html),
            Uri url =>
                renderer.RenderUrlAsPdf(url.ToString()),
            FileInfo { Extension: ".html" } file =>
                renderer.RenderHtmlAsPdf(File.ReadAllText(file.FullName)),
            null => throw new ArgumentNullException("Input was null."),
            _ => throw new ArgumentException("Unsupported input type for PDF conversion.")
        };
        pdfDoc.SaveAs("example-input-types.pdf");
        Console.WriteLine("PDF created: example-input-types.pdf");
    }
}

Imports System
Imports System.IO
Imports IronPdf
Friend Class Program
	Shared Sub Main()
		Dim input As Object = New Uri("https://example.com") ' Try changing this to: "<html><body>Hello</body></html>" or new FileInfo("sample.html")
		Dim renderer = New ChromePdfRenderer()
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'		PdfDocument pdfDoc = input switch
'		{
'			string html when html.StartsWith("<html>") => renderer.RenderHtmlAsPdf(html),
'			Uri url =>
'				renderer.RenderUrlAsPdf(url.ToString()),
'			FileInfo { Extension: ".html" } file =>
'				renderer.RenderHtmlAsPdf(File.ReadAllText(file.FullName)),
'			null => throw new ArgumentNullException("Input was null."),
'			_ => throw new ArgumentException("Unsupported input type for PDF conversion.")
'		};
		pdfDoc.SaveAs("example-input-types.pdf")
		Console.WriteLine("PDF created: example-input-types.pdf")
	End Sub
End Class

$vbLabelText $csharpLabel

Aquí, el patrón de propiedad (FileInfo { Extension: ".html" }) y el patrón constante nulo (case null) hacen que la lógica sea más expresiva y robusta.

2. Formatear PDF dinámicamente con patrones de posición y declaración

Supongamos que estás utilizando un registro PdfRequest que incluye una cadena de formato. Puedes aplicar patrones posicionales, patrones de declaración y constantes de cadena para personalizar el formato de PDF.

using System;
using IronPdf;
public record PdfRequest(string Title, string Content, string Format);
class Program
{
    static void Main()
    {
        PdfRequest request = new("My Report", "<h1>Monthly Report</h1><p>Generated by IronPDF.</p>", "A4");
        var renderer = new ChromePdfRenderer();
        // Use fully qualified enum to avoid IronWord conflict
        renderer.RenderingOptions = request switch
        {
            PdfRequest { Format: "A4" } => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.A4
            },
            PdfRequest { Format: "Letter" } => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.Letter
            },
            _ => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.Legal // Fallback
            }
        };
        var pdf = renderer.RenderHtmlAsPdf(request.Content);
        pdf.SaveAs("example-formatted.pdf");
        Console.WriteLine("PDF created: example-formatted.pdf");
    }
}

using System;
using IronPdf;
public record PdfRequest(string Title, string Content, string Format);
class Program
{
    static void Main()
    {
        PdfRequest request = new("My Report", "<h1>Monthly Report</h1><p>Generated by IronPDF.</p>", "A4");
        var renderer = new ChromePdfRenderer();
        // Use fully qualified enum to avoid IronWord conflict
        renderer.RenderingOptions = request switch
        {
            PdfRequest { Format: "A4" } => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.A4
            },
            PdfRequest { Format: "Letter" } => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.Letter
            },
            _ => new IronPdf.ChromePdfRenderOptions
            {
                PaperSize = IronPdf.Rendering.PdfPaperSize.Legal // Fallback
            }
        };
        var pdf = renderer.RenderHtmlAsPdf(request.Content);
        pdf.SaveAs("example-formatted.pdf");
        Console.WriteLine("PDF created: example-formatted.pdf");
    }
}

Imports System
Imports IronPdf
'INSTANT VB TODO TASK: C# 'records' are not converted by Instant VB:
'public record PdfRequest(string Title, string Content, string Format)
Friend Class Program
	Shared Sub Main()
		Dim request As New PdfRequest("My Report", "<h1>Monthly Report</h1><p>Generated by IronPDF.</p>", "A4")
		Dim renderer = New ChromePdfRenderer()
		' Use fully qualified enum to avoid IronWord conflict
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'		renderer.RenderingOptions = request switch
'		{
'			PdfRequest { Format: "A4" } => new IronPdf.ChromePdfRenderOptions
'			{
'				PaperSize = IronPdf.Rendering.PdfPaperSize.A4
'			},
'			PdfRequest { Format: "Letter" } => new IronPdf.ChromePdfRenderOptions
'			{
'				PaperSize = IronPdf.Rendering.PdfPaperSize.Letter
'			},
'			_ => new IronPdf.ChromePdfRenderOptions
'			{
'				PaperSize = IronPdf.Rendering.PdfPaperSize.Legal // Fallback
'			}
'		};
		Dim pdf = renderer.RenderHtmlAsPdf(request.Content)
		pdf.SaveAs("example-formatted.pdf")
		Console.WriteLine("PDF created: example-formatted.pdf")
	End Sub
End Class

$vbLabelText $csharpLabel

Este uso demuestra cómo la expresión coincide con la propiedad correspondiente dentro del registro, siguiendo patrones lógicos basados en valores esperados.

Tamaños de salida

Coincidencia de patrones de conmutación de C# (cómo funciona para desarrolladores): Figura 2: Diferencia de tamaño en las salidas de PDF

3. PDFs basados en roles usando patrones Var y Not

Usa patrones var y not para manejar roles de usuario mientras evitas estados nulos o inesperados.

using System;
using IronPdf;
public abstract record UserRole;
public record Admin(string Email) : UserRole;
public record Viewer(string Email) : UserRole;
public record Guest() : UserRole;
class Program
{
    static void Main()
    {
        UserRole currentUser = new Admin("admin@example.com"); // Try changing to Viewer or Guest
        var pdf = currentUser switch
        {
            Admin { Email: var email } =>
                new ChromePdfRenderer().RenderHtmlAsPdf($"<h1>Admin Dashboard</h1><p>Email: {email}</p>"),
            Viewer =>
                new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Viewer Summary</h1><p>Access limited.</p>"),
            Guest =>
                new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Guest Mode</h1><p>Please sign in.</p>"),
            not null =>
                throw new UnauthorizedAccessException("Unknown role type."),
            null =>
                throw new ArgumentNullException("Role cannot be null.")
        };
        pdf.SaveAs("example-role.pdf");
        Console.WriteLine("PDF created: example-role.pdf");
    }
}

using System;
using IronPdf;
public abstract record UserRole;
public record Admin(string Email) : UserRole;
public record Viewer(string Email) : UserRole;
public record Guest() : UserRole;
class Program
{
    static void Main()
    {
        UserRole currentUser = new Admin("admin@example.com"); // Try changing to Viewer or Guest
        var pdf = currentUser switch
        {
            Admin { Email: var email } =>
                new ChromePdfRenderer().RenderHtmlAsPdf($"<h1>Admin Dashboard</h1><p>Email: {email}</p>"),
            Viewer =>
                new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Viewer Summary</h1><p>Access limited.</p>"),
            Guest =>
                new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Guest Mode</h1><p>Please sign in.</p>"),
            not null =>
                throw new UnauthorizedAccessException("Unknown role type."),
            null =>
                throw new ArgumentNullException("Role cannot be null.")
        };
        pdf.SaveAs("example-role.pdf");
        Console.WriteLine("PDF created: example-role.pdf");
    }
}

Imports System
Imports IronPdf
Public MustOverride ReadOnly Property UserRole() As record
public record Admin(String Email) : UserRole
public record Viewer(String Email) : UserRole
public record Guest() : UserRole
Dim Program As class
If True Then
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'	static void Main()
'	{
'		UserRole currentUser = New Admin("admin@example.com"); ' Try changing to Viewer or Guest
''INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
''		var pdf = currentUser switch
''		{
''			Admin { Email: var email } => new ChromePdfRenderer().RenderHtmlAsPdf($"<h1>Admin Dashboard</h1><p>Email: {email}</p>"),
''			Viewer =>
''				new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Viewer Summary</h1><p>Access limited.</p>"),
''			Guest =>
''				new ChromePdfRenderer().RenderHtmlAsPdf("<h1>Guest Mode</h1><p>Please sign in.</p>"),
''			not null =>
''				throw new UnauthorizedAccessException("Unknown role type."),
''			null =>
''				throw new ArgumentNullException("Role cannot be null.")
''		};
'		pdf.SaveAs("example-role.pdf");
'		Console.WriteLine("PDF created: example-role.pdf");
'	}
End If

$vbLabelText $csharpLabel

Esta estructura mejora la seguridad y la legibilidad del código, mientras aprovecha las declaraciones de variables temporales como var email. La siguiente imagen muestra los diferentes documentos PDF creados basados en diferentes valores de entrada.

Coincidencia de patrones de conmutación de C# (cómo funciona para desarrolladores): Figura 3 - Salida basada en roles

4. Comparación de patrones relacionales basada en datos de usuario

¿Necesitas generar diferentes PDFs dependiendo de los niveles de usuario? Intenta usar dos patrones relacionales para probar si la entrada cae dentro de un rango determinado.

using System;
using IronPdf;
class Program
{
    static void Main()
    {
        int userScore = 85; // Try other values: 45, 70, 101
        string message = userScore switch
        {
            < 60 => "Needs Improvement",
            >= 60 and < 80 => "Satisfactory",
            >= 80 and <= 100 => "Excellent",
            _ => "Invalid score"
        };
        var html = $"<h1>Score Report</h1><p>Score: {userScore}</p><p>Result: {message}</p>";
        var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(html);
        pdf.SaveAs("example-score.pdf");
        Console.WriteLine("PDF created: example-score.pdf");
    }
}

using System;
using IronPdf;
class Program
{
    static void Main()
    {
        int userScore = 85; // Try other values: 45, 70, 101
        string message = userScore switch
        {
            < 60 => "Needs Improvement",
            >= 60 and < 80 => "Satisfactory",
            >= 80 and <= 100 => "Excellent",
            _ => "Invalid score"
        };
        var html = $"<h1>Score Report</h1><p>Score: {userScore}</p><p>Result: {message}</p>";
        var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(html);
        pdf.SaveAs("example-score.pdf");
        Console.WriteLine("PDF created: example-score.pdf");
    }
}

Imports System
Imports IronPdf
Friend Class Program
	Shared Sub Main()
		Dim userScore As Integer = 85 ' Try other values: 45, 70, 101
'INSTANT VB TODO TASK: The following 'switch expression' was not converted by Instant VB:
'		string message = userScore switch
'		{
'			< 60 => "Needs Improvement",
'			>= 60 and < 80 => "Satisfactory",
'			>= 80 and <= 100 => "Excellent",
'			_ => "Invalid score"
'		};
		Dim html = $"<h1>Score Report</h1><p>Score: {userScore}</p><p>Result: {message}</p>"
		Dim pdf = (New ChromePdfRenderer()).RenderHtmlAsPdf(html)
		pdf.SaveAs("example-score.pdf")
		Console.WriteLine("PDF created: example-score.pdf")
	End Sub
End Class

$vbLabelText $csharpLabel

Los operadores relacionales y las expresiones booleanas mantienen el código conciso y expresivo.

Resultado

Coincidencia de patrones de conmutación de C# (cómo funciona para desarrolladores): Figura 4 - Salida basada en puntuación

Consejos para implementar este patrón en sus proyectos

Coincidencia de patrones de conmutación en C# (cómo funciona para desarrolladores): Figura 5 - Hoja de referencia de coincidencia de patrones en C#

Use tipos de registro para objetos de datos limpios e inmutables.
Prefiera expresiones switch sobre árboles if-else para una lógica más limpia.
Use not patterns y discard patterns (_) para ignorar coincidencias irrelevantes.
Añada casos por defecto para capturar entradas desconocidas desde el principio.
Divida casos complejos en métodos auxiliares para mejorar la legibilidad.

Beneficios reales

Código más limpio: no más bloques if-else o switch-case profundamente anidados
Pruebas más fáciles: los casos de patrones aislados simplifican las pruebas unitarias
Flexibilidad: amplíe fácilmente la lógica al agregar nuevos tipos de entrada
Mejor separación de preocupaciones: centrar la lógica únicamente en la transformación de entrada/salida

Conclusión: Modernice su lógica PDF

Switch pattern matching es más que una mejora sintáctica; es un poderoso paradigma para escribir código más seguro y expresivo. Combinado con las capacidades flexibles de renderización de IronPDF, es posible crear canales de generación de documentos más inteligentes y escalables con un mínimo de código.

Ya sea que esté construyendo un generador de informes, un visor de documentos o un sistema de plantillas dinámicas, se recomienda agregar pattern matching a la implementación de IronPDF. Pronto se verán los beneficios en claridad, control y mantenibilidad.