Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Ajuda do .NET
  4. C# Selecionar caso
AJUDA DO .NET

Select Case em C# (Como funciona para desenvolvedores)

Curtis Chau
Curtis Chau
Atualizado:

Em aplicações .NET modernas, a geração dinâmica de PDFs é um requisito comum. Seja para criar relatórios, faturas ou outros documentos, ter uma maneira simplificada de gerar condicionalmente diferentes formatos de PDF é essencial. A instrução switch (também conhecida como Select Case em algumas linguagens) em C# é uma ferramenta poderosa para implementar essa lógica de forma eficiente. A estrutura switch case receberá algum tipo de dado (char, int, string, etc.) e o comparará com os valores das condições para verificar se há alguma correspondência. Caso isso aconteça, o código dentro desse bloco case será executado; Caso contrário, o caso padrão será utilizado se os outros padrões de caso não corresponderem.

IronPDF é uma biblioteca robusta para geração e manipulação de PDFs para desenvolvedores .NET , permitindo converter HTML, imagens e diversos outros conteúdos em PDFs. Ao utilizar a instrução switch do C#, você pode personalizar seus PDFs com base em diferentes condições, como entrada do usuário ou estado dos dados.

Este artigo irá orientá-lo na utilização da instrução switch case em C# com o IronPDF para criar conteúdo PDF dinâmico e condicional, com um bom nível de controle de fluxo dentro do programa, aumentando, em última análise, a eficiência e a legibilidade dos seus programas.

O que é Select Case (Switch) em C#?

Visão geral do Select Case em C

Em C#, a instrução switch (que não deve ser confundida com a expressão switch) fornece uma maneira clara e estruturada de lidar com lógica condicional com base no valor de uma variável. Em vez de usar várias instruções, como as instruções if-else, as instruções switch case permitem um código mais fácil de ler e manter. A instrução switch procurará uma correspondência de padrão para a expressão match passada para a instrução, antes de executar o código dentro do caso padrão se nenhuma correspondência for encontrada.

Veja a estrutura básica de uma instrução switch em C#:

switch (variable)
{
    case value1:
        // action for value1
        break;
    case value2:
        // action for value2
        break;
    default:
        // default action if no case matches
        break;
}
switch (variable)
{
    case value1:
        // action for value1
        break;
    case value2:
        // action for value2
        break;
    default:
        // default action if no case matches
        break;
}
Select Case variable
	Case value1
		' action for value1
	Case value2
		' action for value2
	Case Else
		' default action if no case matches
End Select
$vbLabelText   $csharpLabel

Cada caso representa um valor possível para a variável e, quando uma correspondência é encontrada, o código dentro desse bloco é executado. Isso é particularmente útil quando você tem vários resultados baseados em uma única variável, como determinar qual tipo de documento gerar em PDF.

Integração do Select Case com o IronPDF para geração dinâmica de PDFs.

Utilizando o Select Case para personalizar o conteúdo de PDFs.

Imagine que você está desenvolvendo um sistema onde diferentes tipos de documentos precisam ser gerados dependendo da entrada do usuário. Por exemplo, você pode precisar criar um relatório para um usuário e uma fatura para outro. Com a instrução switch do C#, você pode determinar facilmente qual tipo de PDF gerar usando o IronPDF.

Veja um exemplo de cenário: com base na seleção do usuário, você pode usar uma instrução switch para decidir qual conteúdo HTML renderizar em um documento PDF, combinando a escolha do usuário com o mesmo tipo de valor case.

switch (userChoice)
{
    case "report":
        // Code to generate a report PDF using IronPDF
        break;
    case "invoice":
        // Code to generate an invoice PDF using IronPDF
        break;
    default:
        // Code to generate a default PDF document using IronPDF
        break;
}
switch (userChoice)
{
    case "report":
        // Code to generate a report PDF using IronPDF
        break;
    case "invoice":
        // Code to generate an invoice PDF using IronPDF
        break;
    default:
        // Code to generate a default PDF document using IronPDF
        break;
}
Select Case userChoice
	Case "report"
		' Code to generate a report PDF using IronPDF
	Case "invoice"
		' Code to generate an invoice PDF using IronPDF
	Case Else
		' Code to generate a default PDF document using IronPDF
End Select
$vbLabelText   $csharpLabel

Neste exemplo, o sistema pode gerar vários tipos de documentos reutilizando os poderosos recursos de renderização de PDF do IronPDF, ao mesmo tempo que simplifica a tomada de decisões usando a instrução switch.

Implementação passo a passo

Vamos analisar como integrar o switch do C# com o IronPDF para gerar PDFs. Neste exemplo, vamos lidar com dois tipos de documentos: Relatórios e Faturas .

  1. Instale o IronPDF: Primeiro, você precisará instalar o IronPDF para começar a usá-lo em seus projetos.

  2. Configurar conteúdo HTML para diferentes tipos de documento:
    Crie modelos HTML para seu relatório e fatura. Isso permite que o IronPDF renderize esses modelos em um PDF.

  3. Utilize a instrução switch para seleção dinâmica:
    Com base na entrada do usuário (ou qualquer outra variável), use a instrução switch para determinar qual modelo HTML usar e passe-o para o IronPDF para renderização em PDF.

Instalando o IronPDF

Para começar a usar o IronPDF , primeiro você precisará instalá-lo. Se já estiver instalado, você pode pular para a próxima seção. Caso contrário, os passos seguintes explicam como instalar a biblioteca IronPDF .

Através do console do Gerenciador de Pacotes NuGet

Para instalar o IronPDF usando o Console do Gerenciador de Pacotes NuGet , abra o Visual Studio e navegue até o Console do Gerenciador de Pacotes. Em seguida, execute o seguinte comando:

Install-Package IronPdf

Por meio do Gerenciador de Pacotes NuGet para Soluções

Ao abrir o Visual Studio, acesse "Ferramentas -> Gerenciador de Pacotes NuGet -> Gerenciar Pacotes NuGet para a Solução" e procure por IronPDF. A partir daqui, tudo o que você precisa fazer é selecionar seu projeto, clicar em "Instalar" e o IronPDF será adicionado ao seu projeto.

C# Select Case (Como funciona para desenvolvedores): Figura 1

Após instalar o IronPDF, tudo o que você precisa adicionar para começar a usá IronPDF é a instrução using correta no início do seu código:

using IronPdf;
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Exemplo: Gerando PDFs com estilos diferentes usando o IronPDF

Estudo de caso: Geração de relatórios versus emissão de faturas

Vamos analisar mais de perto um caso de uso no mundo real. Imagine que você está desenvolvendo um sistema para uma empresa que precisa gerar relatórios e faturas para seus clientes. Dependendo da seleção do usuário, você pode gerar conteúdos diferentes em um PDF.

  1. Geração de relatórios:

    Quando o usuário seleciona "Relatório", o sistema gera um PDF com conteúdo específico do relatório. Utilizando modelos HTML, você pode personalizar facilmente a estrutura do conteúdo.

    case "Report":
   string reportHtml = "<h1>Monthly Report</h1><p>This report provides a detailed overview of activities.</p>";
   PdfDocument reportPdf = pdfRenderer.RenderHtmlAsPdf(reportHtml);
   reportPdf.SaveAs("Monthly_Report.pdf");
   break;
    case "Report":
   string reportHtml = "<h1>Monthly Report</h1><p>This report provides a detailed overview of activities.</p>";
   PdfDocument reportPdf = pdfRenderer.RenderHtmlAsPdf(reportHtml);
   reportPdf.SaveAs("Monthly_Report.pdf");
   break;
    Case "Report"
   Dim reportHtml As String = "<h1>Monthly Report</h1><p>This report provides a detailed overview of activities.</p>"
   Dim reportPdf As PdfDocument = pdfRenderer.RenderHtmlAsPdf(reportHtml)
   reportPdf.SaveAs("Monthly_Report.pdf")
   break
    $vbLabelText   $csharpLabel

  2. Geração de faturas:

    Para faturas, você pode incluir informações de cobrança e listas detalhadas no HTML, que o IronPDF converterá em um PDF de alta qualidade.

    case "Invoice":
   string invoiceHtml = "<h1>Invoice #12345</h1><p>Billing details and itemized list here.</p>";
   PdfDocument invoicePdf = pdfRenderer.RenderHtmlAsPdf(invoiceHtml);
   invoicePdf.SaveAs("Invoice_12345.pdf");
   break;
    case "Invoice":
   string invoiceHtml = "<h1>Invoice #12345</h1><p>Billing details and itemized list here.</p>";
   PdfDocument invoicePdf = pdfRenderer.RenderHtmlAsPdf(invoiceHtml);
   invoicePdf.SaveAs("Invoice_12345.pdf");
   break;
    Case "Invoice"
   Dim invoiceHtml As String = "<h1>Invoice #12345</h1><p>Billing details and itemized list here.</p>"
   Dim invoicePdf As PdfDocument = pdfRenderer.RenderHtmlAsPdf(invoiceHtml)
   invoicePdf.SaveAs("Invoice_12345.pdf")
   break
    $vbLabelText   $csharpLabel

Essa abordagem garante que você mantenha a flexibilidade e a reutilização do seu código, pois pode facilmente estender a instrução switch para lidar com tipos de documento adicionais.

Exemplo de código: Criando relatórios e faturas usando IronPDF e instruções switch

No exemplo de código a seguir, usaremos a entrada do usuário para passar para a instrução Switch, a fim de determinar qual PDF será gerado. 

using IronPdf;
using System;

public class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine("What do you want to create?");
        Console.WriteLine("a. Report");
        Console.WriteLine("b. Invoice");
        var input = Console.ReadLine();
        string docType;

        if (input == "a")
        {
            GeneratePdf("Report");
        }
        else if (input == "b")
        {
            GeneratePdf("Invoice");
        }
        else
        {
            GeneratePdf(null);
        }
    }

    public static void GeneratePdf(string docType)
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        switch (docType)
        {
            case "Report":
                string reportHtml = "<h1>Report</h1><p>This is a dynamically generated report.</p>";
                PdfDocument reportPdf = renderer.RenderHtmlAsPdf(reportHtml);
                reportPdf.SaveAs("Report.pdf");
                break;
            case "Invoice":
                string invoiceHtml = "<h1>Invoice</h1><p>This is a dynamically generated invoice.</p>";
                PdfDocument invoicePdf = renderer.RenderHtmlAsPdf(invoiceHtml);
                invoicePdf.SaveAs("Invoice.pdf");
                break;
            default:
                string defaultHtml = "<h1>Document</h1><p>This is a default PDF document.</p>";
                PdfDocument defaultPdf = renderer.RenderHtmlAsPdf(defaultHtml);
                defaultPdf.SaveAs("Default.pdf");
                break;
        }
    }
}
using IronPdf;
using System;

public class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine("What do you want to create?");
        Console.WriteLine("a. Report");
        Console.WriteLine("b. Invoice");
        var input = Console.ReadLine();
        string docType;

        if (input == "a")
        {
            GeneratePdf("Report");
        }
        else if (input == "b")
        {
            GeneratePdf("Invoice");
        }
        else
        {
            GeneratePdf(null);
        }
    }

    public static void GeneratePdf(string docType)
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        switch (docType)
        {
            case "Report":
                string reportHtml = "<h1>Report</h1><p>This is a dynamically generated report.</p>";
                PdfDocument reportPdf = renderer.RenderHtmlAsPdf(reportHtml);
                reportPdf.SaveAs("Report.pdf");
                break;
            case "Invoice":
                string invoiceHtml = "<h1>Invoice</h1><p>This is a dynamically generated invoice.</p>";
                PdfDocument invoicePdf = renderer.RenderHtmlAsPdf(invoiceHtml);
                invoicePdf.SaveAs("Invoice.pdf");
                break;
            default:
                string defaultHtml = "<h1>Document</h1><p>This is a default PDF document.</p>";
                PdfDocument defaultPdf = renderer.RenderHtmlAsPdf(defaultHtml);
                defaultPdf.SaveAs("Default.pdf");
                break;
        }
    }
}
Imports IronPdf
Imports System

Public Class Program
	Public Shared Sub Main(ByVal args() As String)
		Console.WriteLine("What do you want to create?")
		Console.WriteLine("a. Report")
		Console.WriteLine("b. Invoice")
		Dim input = Console.ReadLine()
		Dim docType As String

		If input = "a" Then
			GeneratePdf("Report")
		ElseIf input = "b" Then
			GeneratePdf("Invoice")
		Else
			GeneratePdf(Nothing)
		End If
	End Sub

	Public Shared Sub GeneratePdf(ByVal docType As String)
		Dim renderer As New ChromePdfRenderer()
		Select Case docType
			Case "Report"
				Dim reportHtml As String = "<h1>Report</h1><p>This is a dynamically generated report.</p>"
				Dim reportPdf As PdfDocument = renderer.RenderHtmlAsPdf(reportHtml)
				reportPdf.SaveAs("Report.pdf")
			Case "Invoice"
				Dim invoiceHtml As String = "<h1>Invoice</h1><p>This is a dynamically generated invoice.</p>"
				Dim invoicePdf As PdfDocument = renderer.RenderHtmlAsPdf(invoiceHtml)
				invoicePdf.SaveAs("Invoice.pdf")
			Case Else
				Dim defaultHtml As String = "<h1>Document</h1><p>This is a default PDF document.</p>"
				Dim defaultPdf As PdfDocument = renderer.RenderHtmlAsPdf(defaultHtml)
				defaultPdf.SaveAs("Default.pdf")
		End Select
	End Sub
End Class
$vbLabelText   $csharpLabel

C# Select Case (Como funciona para desenvolvedores): Figura 2

Neste exemplo, a instrução switch controla qual tipo de documento será gerado. Se o tipo de documento for "Relatório", será criado um PDF do relatório. Se for "Fatura", uma fatura será gerada. Caso nenhuma correspondência seja encontrada, um PDF padrão será criado.

Por que escolher o IronPDF para seus projetos .NET ?

O IronPDF se destaca por sua capacidade de renderizar HTML, CSS, JavaScript e até mesmo conteúdo dinâmico em C# diretamente em PDFs. Ao integrá-lo com a instrução switch do C#, você pode simplificar o processo de geração de documentos, tornando-o mais eficiente e fácil de manter.

Algumas das principais vantagens do IronPDF incluem:

  • Integração simples: Converta facilmente HTML , imagens e muito mais em PDFs com configuração mínima.
  • Conjunto completo de recursos: o IronPDF oferece suporte a recursos como cabeçalhos, rodapés, marcas d'água e muito mais.
  • Suporte multiplataforma: Funciona em ambientes .NET Core, .NET Framework e Azure.

Para saber mais sobre o conjunto robusto de recursos que o IronPDF oferece, confira o prático guia disponível. Você pode explorar todos os recursos sem riscos antes de se comprometer.

Conclusão

Ao utilizar a instrução switch case do C# e o IronPDF , você pode criar documentos PDF dinâmicos e personalizáveis ​​com o mínimo de esforço. Seja para gerar relatórios, faturas ou outros tipos de documentos, essa combinação oferece flexibilidade e eficiência. Utilizar instruções como a instrução if funciona muito bem se você estiver processando apenas um ou dois resultados possíveis, mas as instruções switch podem melhorar bastante a clareza do seu código ao trabalhar com múltiplos resultados.

Usar o bloco switch para gerar diferentes tipos de PDF é uma ótima maneira de levar o IronPDF a um nível totalmente novo. Com um amplo conjunto de recursos avançados, ótimo desempenho e compatibilidade multiplataforma, o IronPDF é uma poderosa ferramenta de geração de PDFs que você pode ter à disposição. Não acredite apenas na nossa palavra — baixe a versão de avaliação gratuita hoje mesmo e veja por si mesmo como ela pode otimizar seus fluxos de trabalho com PDFs!

Perguntas frequentes

Como posso usar uma instrução switch para gerar diferentes formatos de PDF em C#?

Em C#, você pode usar a instrução `switch` para decidir qual modelo HTML renderizar como PDF utilizando uma biblioteca PDF. Isso permite gerar dinamicamente diferentes tipos de documentos, como relatórios ou faturas, com base na entrada do usuário ou no estado da aplicação.

Qual a vantagem de usar uma instrução switch para geração de PDF?

O uso de uma instrução switch melhora a legibilidade e a manutenção do código, permitindo o gerenciamento eficiente de múltiplos resultados com base em uma única variável. Isso é especialmente útil na geração de diversos formatos de PDF, como relatórios e faturas, em aplicações .NET.

Como faço para instalar uma biblioteca PDF no .NET para geração de documentos?

Para instalar uma biblioteca PDF em um projeto .NET, você pode usar o Console do Gerenciador de Pacotes NuGet ou o Gerenciador de Pacotes NuGet para Soluções no Visual Studio. Isso permite integrar facilmente recursos de geração de PDF ao seu aplicativo.

Posso usar bibliotecas PDF em um ambiente .NET multiplataforma?

Sim, muitas bibliotecas de PDF são projetadas para funcionar em ambientes multiplataforma e oferecem suporte ao .NET Core, .NET Framework e Azure, permitindo a geração de PDFs em diversas plataformas.

Quais são as características comuns das bibliotecas PDF para desenvolvimento em C#?

Bibliotecas de PDF para C# geralmente oferecem recursos como conversão de HTML para PDF, suporte para adição de imagens, cabeçalhos, rodapés, marcas d'água e muito mais. Essas ferramentas fornecem soluções abrangentes para gerar e manipular PDFs em aplicativos .NET.

Por que os desenvolvedores .NET devem usar uma biblioteca PDF robusta?

Uma biblioteca robusta para PDFs é essencial para desenvolvedores .NET, pois oferece recursos confiáveis para gerar e manipular PDFs. Ela suporta a conversão de conteúdo HTML, CSS, JavaScript e C# dinâmico em PDFs, oferecendo simplicidade, desempenho e funcionalidade multiplataforma.

Como posso solucionar problemas ao gerar PDFs com uma instrução switch?

Ao solucionar problemas de geração de PDFs usando uma instrução switch, certifique-se de que os tipos de dados usados nos casos do switch correspondam à entrada esperada. Além disso, verifique se os modelos HTML corretos estão selecionados e renderizados em PDFs usando os métodos apropriados da biblioteca PDF.

Qual a diferença entre instruções switch e if-else para lógica condicional?

As instruções switch oferecem uma abordagem estruturada e organizada para lidar com múltiplas ramificações condicionais em comparação com as instruções if-else. Elas melhoram a legibilidade do código e são particularmente benéficas ao lidar com múltiplos resultados baseados em uma única variável, como em cenários de geração de PDFs.

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