Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Ajuda do .NET
  4. Correspondência de padrões em C# Switch
AJUDA DO .NET

Correspondência de padrões com switch em C# (Como funciona para desenvolvedores)

Curtis Chau
Curtis Chau
Atualizado:

Trabalhar com arquivos PDF em C# geralmente envolve lidar com diferentes tipos de documentos, ações ou fontes de dados. Tradicionalmente, os desenvolvedores podem recorrer a longas cadeias if-else ou instruções switch aninhadas para gerenciar vários valores e tipos de entrada ou decisões de saída. Mas com recursos modernos do C#, como o casamento de padrões com o switch , seu código pode se tornar muito mais elegante, legível e fácil de manter.

Quando combinada com uma biblioteca PDF poderosa como o IronPDF , a correspondência de padrões de alternância permite criar uma lógica mais inteligente e limpa para o processamento de documentos. Neste artigo, exploraremos como usar os recursos avançados de correspondência de padrões do C# — como padrões de tipo, padrões de propriedade e padrões relacionais — juntamente com o IronPDF para otimizar seus fluxos de trabalho de geração de PDFs.

O que é a correspondência de padrões com Switch em C#?

O recurso de correspondência de padrões do Switch foi introduzido no C# 7 e aprimorado continuamente em versões posteriores. Ao contrário das instruções switch tradicionais, que só correspondem a valores constantes, o casamento de padrões permite avaliar tipos, propriedades e condições em uma única expressão. O exemplo a seguir demonstra como esse recurso funciona.

Exemplo de sintaxe

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 padrões de tipo, operadores relacionais e um padrão de constante nula para lidar com múltiplos casos de forma concisa. Essa técnica melhora significativamente a legibilidade do código, com uma sintaxe mais concisa e suporte a lógicas mais complexas.

Por que combinar o Switch Pattern Matching com o IronPDF?

Correspondência de padrões do switch em C# (Como funciona para desenvolvedores): Figura 1 - Página inicial do IronPDF

IronPDF é um poderoso componente .NET para gerar e manipular PDFs a partir de HTML, imagens ou texto bruto. Muitos casos de uso no mundo real envolvem o processamento de diferentes padrões de entrada: alguns documentos podem ter origem em URLs, outros em strings HTML e outros em uploads de arquivos.

Em vez de testar expressões com condições if complicadas, o casamento de padrões com switch permite que você dê suporte à lógica baseada em padrões de forma eficiente. Ele permite definir como seu aplicativo responde a diferentes tipos de objetos, constantes específicas ou até mesmo expressões booleanas, usando a própria expressão de entrada para direcionar o fluxo de trabalho.

Casos de uso comuns no IronPDF com correspondência de padrões

No exemplo anterior, vimos como é a sintaxe básica, mas agora vamos vê-la em ação. Os exemplos de código a seguir são algumas tarefas reais de PDF que se beneficiam da combinação do IronPDF com a correspondência de padrões em C#.

1. Lidar com múltiplos formatos de entrada usando padrões de tipo e propriedade

Suponhamos que seu método aceite vários formatos de entrada: HTML, um Uri ou um arquivo .html local. Usando padrões de tipo, padrões de propriedade e padrões nulos, você pode distinguir esses casos sem esforço.

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

Aqui, o padrão de propriedade (FileInfo { Extension: ".html" }) e o padrão de constante nula (case null) tornam a lógica mais expressiva e robusta.

2. Formate PDFs dinamicamente com padrões posicionais e de declaração.

Suponha que você esteja usando um registro PdfRequest que inclui uma string de formatação. Você pode aplicar padrões posicionais, padrões de declaração e constantes de string para personalizar a formatação de PDFs.

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 exemplo demonstra como a expressão corresponde à propriedade correspondente no registro, seguindo padrões lógicos baseados em valores esperados.

Tamanhos de saída

Correspondência de padrões do Switch em C# (Como funciona para desenvolvedores): Figura 2 - Diferença de tamanho nas saídas em PDF

3. PDFs baseados em funções usando padrões Var e Not

Use padrões var em vez de padrões not para gerenciar funções de usuário, evitando estados nulos ou 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

Essa estrutura melhora a segurança e a legibilidade do código, ao mesmo tempo que aproveita declarações de variáveis ​​temporárias, como var email. A imagem a seguir mostra os diferentes documentos PDF criados com base em diferentes valores de entrada.

Correspondência de padrões do Switch em C# (Como funciona para desenvolvedores): Figura 3 - Saída baseada em função

4. Correspondência de padrões relacionais com base em dados do usuário

Precisa gerar PDFs diferentes dependendo do nível de acesso do usuário? Tente usar dois padrões relacionais para verificar se a entrada está dentro de um determinado intervalo.

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

Os operadores relacionais e as expressões booleanas mantêm o código conciso e expressivo.

Saída

Correspondência de padrões do Switch em C# (Como funciona para desenvolvedores): Figura 4 - Saída baseada em pontuação

Dicas para implementar esse padrão em seus projetos

Correspondência de Padrões em C# com Switch (Como Funciona para Desenvolvedores): Figura 5 - Guia Rápido de Correspondência de Padrões em C#

  • Utilize tipos de registro para objetos de dados limpos e imutáveis.
  • Prefira expressões switch em vez de árvores if-else para uma lógica mais limpa.
  • Use padrões de não e descarte (_) para ignorar correspondências irrelevantes.
  • Adicione casos padrão para detectar entradas desconhecidas antecipadamente.
  • Divida os casos complexos em métodos auxiliares para facilitar a leitura.

Benefícios no mundo real

  • Código mais limpo: Sem blocos if-else ou switch-case profundamente aninhados
  • Testes mais fáceis: casos de padrões isolados simplificam os testes unitários
  • Flexibilidade: Amplie facilmente a lógica ao adicionar novos tipos de entrada.
  • Melhor Separação de Responsabilidades: Concentre a lógica apenas na transformação de entrada/saída.

Conclusão: Modernize a lógica dos seus PDFs

A correspondência de padrões com o switch é mais do que apenas uma melhoria sintática; é um paradigma poderoso para escrever código mais seguro e expressivo. Combinando isso com os recursos flexíveis de renderização do IronPDF, você pode criar fluxos de trabalho de geração de documentos mais inteligentes e escaláveis ​​com o mínimo de código.

Seja para criar um gerador de relatórios, um visualizador de documentos ou um sistema de modelos dinâmicos, experimente adicionar a correspondência de padrões à sua implementação do IronPDF . Você perceberá rapidamente os benefícios em termos de clareza, controle e facilidade de manutenção.

Quer experimentar o IronPDF você mesmo?

Baixe a versão de avaliação gratuita para experimentar os poderosos recursos do IronPDF antes de adquirir uma licença.

Perguntas frequentes

Como o padrão de correspondência `switch` em C# pode ser aplicado ao processamento de documentos?

O casamento de padrões com switch em C# pode ser usado para simplificar lógicas complexas de tomada de decisão. Quando integrado a uma biblioteca PDF como o IronPDF, permite que os desenvolvedores gerenciem tarefas de processamento de documentos com mais eficiência, otimizando a lógica de decisão e melhorando a legibilidade do código.

Quais são as vantagens de usar o casamento de padrões com a estrutura `switch` em vez das tradicionais instruções `if-else`?

O padrão de correspondência `switch` oferece uma maneira mais concisa e legível de lidar com múltiplas condições em comparação com as tradicionais instruções `if-else`. Ele aprimora a manutenção do código C#, especialmente ao lidar com tarefas complexas de processamento de documentos usando o IronPDF.

Como a correspondência de padrões de alternância facilita a automação de documentos PDF?

A correspondência de padrões de alternância facilita a automação de documentos PDF, permitindo que os desenvolvedores criem uma lógica mais limpa para gerenciar diversas ações e tipos de dados em documentos. Quando usada com o IronPDF, ela ajuda a automatizar fluxos de trabalho e a otimizar os processos de extração de dados.

É possível usar o recurso de correspondência de padrões com switch para lidar com fluxos de trabalho de documentos complexos em C#?

Sim, o padrão de correspondência `switch` é muito adequado para lidar com fluxos de trabalho de documentos complexos em C#. Ele simplifica a lógica necessária para gerenciar diferentes tipos de documentos e ações, especialmente quando usado em conjunto com bibliotecas robustas como o IronPDF.

Como implementar o casamento de padrões com switch em uma aplicação de processamento de PDF em C#?

Em uma aplicação de processamento de PDF em C#, você pode implementar a correspondência de padrões usando a instrução switch com a sintaxe de correspondência de padrões para gerenciar diferentes tipos de documentos ou condições de processamento. O IronPDF pode ser usado para lidar com as tarefas de manipulação de PDF.

Quais desafios os desenvolvedores podem enfrentar ao usar o padrão de correspondência `switch` em C#?

Os desenvolvedores podem enfrentar desafios com a correspondência de padrões do tipo `switch` ao lidar com padrões dinâmicos ou baseados em tempo de execução que exigem uma lógica mais complexa. No entanto, quando usado corretamente com uma biblioteca como o IronPDF, ele pode aumentar significativamente a eficiência do código.

Como o casamento de padrões com switches contribui para a manutenção do código?

O casamento de padrões com switch contribui para a manutenção do código, fornecendo uma maneira clara e concisa de lidar com múltiplas condições. Isso reduz a complexidade e torna o código mais fácil de entender e modificar, especialmente em aplicações de grande escala que utilizam o IronPDF.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim