In modernen .NET-Anwendungen ist das dynamische Erzeugen von PDFs eine häufige Anforderung. Egal, ob Sie Berichte, Rechnungen oder andere Dokumente erstellen, es ist wichtig, einen reibungslosen Weg zu haben, um bedingt verschiedene PDF-Formate zu erzeugen. Die Switch-Anweisung (auch bekannt als Select Case in einigen Sprachen) in C# ist ein leistungsstarkes Tool, um solche Logik effizient zu implementieren. Die Switch-Anweisung wird einen Datentyp (Char, Int, String usw.) nehmen und ihn mit den Fallwerten vergleichen, um zu sehen, ob einer übereinstimmt. Wenn dies der Fall ist, wird der Code innerhalb dieses Blockes ausgeführt; ansonsten wird der Standardfall ausgeführt, wenn die anderen Fallmuster nicht übereinstimmen.

IronPDF ist eine robuste PDF-Erstellungs- und Manipulationsbibliothek für .NET-Entwickler, die es Ihnen ermöglicht, HTML, Bilder und verschiedene andere Inhalte in PDFs zu konvertieren. Durch die Nutzung der Switch-Anweisung von C# können Sie Ihre PDFs basierend auf verschiedenen Bedingungen anpassen, wie z.B. Benutzereingaben oder Datenzustand.

Dieser Artikel führt Sie durch die Verwendung der Switch-Anweisung in C# mit IronPDF, um dynamische, bedingte PDF-Inhalte zu erstellen, mit einem guten Maß an Kontrollfluss innerhalb des Programms, was letztlich die Effizienz und Lesbarkeit Ihrer Programme erhöht.

What is Select Case (Switch) in C#?

Überblick über C# Select Case

In C# bietet die Switch-Anweisung (nicht zu verwechseln mit dem Switch-Ausdruck) eine saubere und strukturierte Möglichkeit, bedingte Logik basierend auf dem Wert einer Variablen zu handhaben. Anstatt mehrere Anweisungen wie If-Else-Anweisungen zu verwenden, ermöglichen Switch-Case-Anweisungen einen leichter lesbaren und besser wartbaren Code. Die Switch-Anweisung sucht nach einem Mustermatch für den Ausdruck, der an die Anweisung übergeben wird, bevor der Code innerhalb des Standardfalls ausgeführt wird, wenn keine Übereinstimmung gefunden wird.

Hier ist die grundlegende Struktur einer Switch-Anweisung in 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

Select Case variable
	Case value1
		' action for value1
	Case value2
		' action for value2
	Case Else
		' default action if no case matches
End Select

Jeder Fall repräsentiert einen möglichen Wert für die Variable, und wenn eine Übereinstimmung gefunden wird, wird der Code innerhalb dieses Blocks ausgeführt. Dies ist besonders nützlich, wenn Sie mehrere Ergebnisse basierend auf einer einzigen Variablen haben, wie z.B. die Bestimmung, welche Art von Dokument in einem PDF generiert werden soll.

Integration von Select Case mit IronPDF für die dynamische PDF-Generierung

Verwendung von Select Case für die Anpassung von PDF-Inhalten

Stellen Sie sich vor, Sie entwickeln ein System, in dem verschiedene Arten von Dokumenten generiert werden müssen, abhängig von der Benutzereingabe. Zum Beispiel müssen Sie möglicherweise für einen Benutzer einen Bericht und für einen anderen eine Rechnung erstellen. Mit der Switch-Anweisung von C# können Sie ganz einfach bestimmen, welcher PDF-Typ mit IronPDF generiert werden soll.

Hier ist ein Beispielszenario: Basierend auf der Auswahl eines Benutzers können Sie eine Switch-Anweisung verwenden, um zu entscheiden, welcher HTML-Inhalt in ein PDF-Dokument gerendert werden soll, indem die Auswahl des Benutzers mit demselben Fallwert abgeglichen wird.

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

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

In diesem Beispiel kann das System durch die Wiederverwendung von IronPDF's leistungsstarken PDF-Rendering-Fähigkeiten mehrere Arten von Dokumenten generieren, während die Entscheidungsfindung mit der Switch-Anweisung vereinfacht wird.

Schrittweise Implementierung

Lassen Sie uns durchgehen, wie man die Switch-Anweisung von C# mit IronPDF zur Generierung von PDFs integriert. Für dieses Beispiel werden wir zwei Dokumenttypen behandeln: Berichte und Rechnungen.

1. Installieren Sie IronPDF: Zuerst müssen Sie IronPDF installieren, um es in Ihren Projekten verwenden zu können.

2. HTML-Inhalte für verschiedene Dokumenttypen einrichten: Erstellen Sie HTML-Vorlagen für Ihren Bericht und Ihre Rechnung. Dies ermöglicht es IronPDF, diese Vorlagen in ein PDF zu rendern.

3. Verwenden Sie die switch-Anweisung zur dynamischen Auswahl: Basierend auf Benutzereingaben (oder einer anderen Variablen), verwenden Sie die Switch-Anweisung, um zu bestimmen, welche HTML-Vorlage verwendet werden soll und übergeben Sie sie an IronPDF zur PDF-Erstellung.

Installation von IronPDF

Um IronPDF zu verwenden, müssen Sie es zuerst installieren. Wenn es bereits installiert ist, können Sie zum nächsten Abschnitt übergehen. Andernfalls decken die folgenden Schritte ab, wie die IronPDF-Bibliothek installiert wird.

Über die NuGet-Paketmanager-Konsole

Um IronPDF über die NuGet-Paketmanager-Konsole zu installieren, öffnen Sie Visual Studio und navigieren Sie zur Paketmanager-Konsole. Führen Sie dann den folgenden Befehl aus:

Install-Package IronPdf

Über den NuGet Package Manager für Solution

Öffnen Sie Visual Studio, gehen Sie zu "Tools -> NuGet-Paket-Manager -> Verwalten von NuGet-Paketen für die Lösung" und suchen Sie nach IronPDF. Von hier aus müssen Sie nur noch Ihr Projekt auswählen, auf "Installieren" klicken, und IronPDF wird Ihrem Projekt hinzugefügt.

Sobald Sie IronPDF installiert haben, müssen Sie nur noch die richtige using-Anweisung zu Beginn Ihres Codes hinzufügen, um IronPDF verwenden zu können:

using IronPdf;

using IronPdf;

Imports IronPdf

Imports IronPdf

Beispiel: Erzeugen von PDFs mit verschiedenen Stilen mit IronPDF

Fallstudie: Erstellen von Berichten und Rechnungen

Schauen wir uns einen realen Anwendungsfall genauer an. Angenommen, Sie entwickeln ein System für ein Unternehmen, das sowohl Berichte als auch Rechnungen für seine Kunden generieren muss. Abhängig von der Auswahl des Benutzers können Sie verschiedene Inhalte in ein PDF rendern.

1. Berichterstellung:

Wenn der Benutzer "Bericht" auswählt, erstellt das System ein PDF mit berichtsspezifischem Inhalt. Mithilfe von HTML-Vorlagen können Sie die Inhaltsstruktur leicht anpassen.

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

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

2. Rechnungserstellung:

   Für Rechnungen können Sie Abrechnungsinformationen und aufgeschlüsselte Listen innerhalb des HTML hinzufügen, die IronPDF in ein hochwertiges PDF konvertiert.

   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

   C#VB

Dieser Ansatz stellt sicher, dass Sie Flexibilität und Wiederverwendbarkeit in Ihrem Code beibehalten, da Sie die Switch-Anweisung problemlos erweitern können, um zusätzliche Dokumenttypen zu handhaben.

Code-Beispiel: Erstellen von Berichten und Rechnungen mit IronPDF und Switch Statements

Im folgenden Codebeispiel nehmen wir Benutzereingaben entgegen, um diese an die Switch-Anweisung weiterzuleiten, um zu bestimmen, welches PDF generiert wird.

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

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

In diesem Beispiel steuert die Switch-Anweisung, welcher Dokumenttyp erstellt wird. Wenn der docType "Bericht" ist, wird ein Bericht als PDF erstellt. Wenn es "Rechnung" ist, wird eine Rechnung generiert. Bei keiner Übereinstimmung wird ein Standard-PDF erstellt.

Warum IronPDF für Ihre .NET-Projekte wählen?

IronPDF sticht hervor durch seine Fähigkeit, HTML, CSS, JavaScript und sogar dynamische C#-Inhalte direkt in PDFs zu rendern. Durch die Integration mit der Switch-Anweisung von C# können Sie Ihren Dokumentenerstellungsprozess optimieren und effizienter und wartbarer gestalten.

Einige Schlüsselvorteile von IronPDF sind:

• Einfache Integration: Konvertieren Sie ganz einfach HTML, Bilder und mehr in PDFs mit minimaler Konfiguration.
• Umfangreiches Funktionsset: IronPDF unterstützt Funktionen wie Kopf- und Fußzeilen, Wasserzeichen und mehr.
• Plattformübergreifende Unterstützung: Funktioniert in .NET Core, .NET Framework und Azure-Umgebungen.

Um mehr über das umfangreiche Funktionsset von IronPDF zu erfahren, schauen Sie sich unbedingt das praktische How-to an, das Ihnen zur Verfügung steht, um alle Funktionen risikofrei zu erkunden, bevor Sie sich festlegen.

Abschluss

Durch die Nutzung der Switch-Anweisung von C# und IronPDF können Sie mit minimalem Aufwand dynamische, anpassbare PDF-Dokumente erstellen. Ob Sie Berichte, Rechnungen oder andere Arten von Dokumenten erstellen müssen, diese Kombination bietet Flexibilität und Effizienz. Wenn Sie Anweisungen wie eine If-Anweisung verwenden, funktioniert dies gut, wenn Sie nur ein oder zwei potenzielle Ergebnisse verarbeiten, aber Switch-Anweisungen können die Klarheit Ihres Codes erheblich verbessern, wenn Sie mit mehreren Ergebnissen arbeiten.

Die Verwendung des Switch-Blocks zum Ausgeben unterschiedlicher PDF-Typen ist eine großartige Möglichkeit, IronPDF auf eine ganz neue Ebene zu heben. Mit einer umfangreichen Reihe von reichhaltigen Funktionen, großartiger Leistung und plattformübergreifender Kompatibilität ist IronPDF ein leistungsstarkes PDF-Generierungswerkzeug, das Ihnen zur Verfügung steht. Verlassen Sie sich nicht nur auf unser Wort – laden Sie heute die kostenlose Testversion herunter und sehen Sie selbst, wie es Ihre PDF-Workflows optimieren kann!