Was sind optionale Parameter in C# und wie werden sie verwendet?

Optionale Parameter in C# ermöglichen es Entwicklern, Methoden zu definieren, die mit weniger Argumenten aufgerufen werden können, indem Standardwerte für einige Parameter angegeben werden. Das bedeutet, wenn ein Argument beim Methodenaufruf weggelassen wird, wird der Standardwert verwendet.

Wie können benannte Parameter die Lesbarkeit des Codes in C# verbessern?

Benannte Parameter verbessern die Lesbarkeit des Codes, indem sie dem Entwickler ermöglichen zu spezifizieren, welche Parameter direkt im Methodenaufruf Wertzuweisungen erhalten. Dies ist besonders nützlich bei Methoden mit mehreren Parametern, da es verdeutlicht, welche Argumente zu welchen Parametern gehören.

Was ist der Unterschied zwischen optionalen Parametern und Methodenüberladung in C#?

Optionale Parameter erlauben es einer einzigen Methode, mit einer variierenden Anzahl von Argumenten umzugehen, während Methodenüberladung die Erstellung mehrerer Versionen einer Methode mit unterschiedlichen Parametern beinhaltet. Optionale Parameter reduzieren die Komplexität, indem sie mehrere Methodendefinitionen vermeiden.

Wie können optionale Parameter bei der Verwendung einer .NET-Bibliothek zur PDF-Erstellung von Vorteil sein?

Bei der Verwendung einer .NET-Bibliothek zur PDF-Erstellung können optionale Parameter die Methodenaufrufe vereinfachen, indem es Entwicklern ermöglicht wird, nur die notwendigen Argumente zur Erzeugung von PDFs anzugeben. Diese Flexibilität hilft dabei, PDF-Inhalte, Layouts und Dateieigenschaften anzupassen, ohne dass mehrere Überladungen nötig sind.

Was sind die Best Practices für die Verwendung optionaler Parameter in C#?

Zu den Best Practices für die Verwendung optionaler Parameter gehört es, ihre Verwendung zu begrenzen, um Verwirrung zu vermeiden, sicherzustellen, dass Standardwerte gut dokumentiert sind, und sie in Verbindung mit benannten Parametern zu verwenden, um die Klarheit bei Methodenanrufen zu verbessern.

Wie profitieren Methodenentwürfe von der Kombination festgelegter und optionaler Parameter?

Durch die Kombination festgelegter und optionaler Parameter können Entwickler bestimmte Eingaben verlangen und gleichzeitig für andere Eingaben Flexibilität bieten. Diese Entwurfsstrategie stellt sicher, dass die notwendigen Daten bereitgestellt werden, während die Methodenschnittstelle für zusätzliche, nicht wesentliche Eingaben vereinfacht wird.

Wie können Sie die Erstellung von PDF-Berichten mit optionalen Parametern in C# vereinfachen?

Optionale Parameter in C# können die Erstellung von PDF-Berichten rationalisieren, indem sie Entwicklern ermöglichen, nur die notwendigen Daten wie Titel oder Autor anzugeben, während sie standardmäßige Einstellungen für andere Parameter wie Dateipfad oder Seitenlayout verwenden, wodurch die Notwendigkeit für mehrere Methodenversionen reduziert wird.

What distinguishes method overloading from using optional parameters?

Method overloading involves creating multiple signatures for different use cases, while optional parameters allow a single method to address various scenarios without overloads.

Why is it important to limit the use of optional parameters?

Overusing optional parameters can complicate method signatures and obscure the method's intent, especially when defaults are not clear or intuitive.

How does optional parameter integration improve PDF generation with IronPDF?

By integrating optional parameters, the PDF generation process in IronPDF becomes more adaptable, providing customized document creation that caters to specific reporting needs with minimal changes.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

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");

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");

PM >Install-Package IronPdf

Install-Package IronPdf

ENTWICKLER-UPDATES

C# Optionale Parameter (Funktionsweise für Entwickler)

Jacob Mellor

Updated: 21. April 2026

Defining Optional Parameters in C#

Grundlegende Syntax

Um einen optionalen Parameter zu definieren, weisen Sie ihm einen Standardwert in der Methodendeklaration zu. Dieser Standardwert muss ein konstanter Ausdruck sein. So können Sie eine Methode mit einem oder mehreren optionalen Standardparametern in der Methodendefinition definieren:

public static void DisplayGreeting(string message, string end = "!")
{
    Console.WriteLine(message + end);
}

public static void DisplayGreeting(string message, string end = "!")
{
    Console.WriteLine(message + end);
}

Public Shared Sub DisplayGreeting(ByVal message As String, Optional ByVal [end] As String = "!")
	Console.WriteLine(message & [end])
End Sub

Public Shared Sub DisplayGreeting(ByVal message As String, Optional ByVal [end] As String = "!")
	Console.WriteLine(message & [end])
End Sub

Im obigen Codeausschnitt ist 'end' ein optionaler Parameter mit einem Standardparameterwert von '!'. Dies erlaubt es, die Methode entweder mit oder ohne Angabe eines zweiten Arguments aufzurufen.

Methodenaufrufe mit optionalen Parametern

Hier sind zwei Möglichkeiten, die obige Methode aufzurufen:

static void Main()
{
    DisplayGreeting("Hello"); // Outputs: Hello!
    DisplayGreeting("Hello", "?"); // Outputs: Hello?
}

static void Main()
{
    DisplayGreeting("Hello"); // Outputs: Hello!
    DisplayGreeting("Hello", "?"); // Outputs: Hello?
}

Shared Sub Main()
	DisplayGreeting("Hello") ' Outputs: Hello!
	DisplayGreeting("Hello", "?") ' Outputs: Hello?
End Sub

Shared Sub Main()
	DisplayGreeting("Hello") ' Outputs: Hello!
	DisplayGreeting("Hello", "?") ' Outputs: Hello?
End Sub

Der erste Aufruf lässt das zweite Argument weg und verwendet den Standardwert. Der zweite Aufruf gibt einen spezifischen Wert an, der den Standardwert überschreibt.

Verwendung von benannten und optionalen Parametern

Benannte und optionale Parameter in C# verbessern die Klarheit von Methodenaufrufen mit optionalen Parametern. Sie erlauben es, anzugeben, welche Parameter Werte erhalten, indem man sie in dem Aufruf direkt benennt.

Beispiel für die Verwendung benannter Parameter

// Named parameters
public static void ConfigureDevice(string deviceName, bool enableLogging = false, int timeout = 30)
{
    Console.WriteLine($"Configuring {deviceName}: Logging={(enableLogging ? "On" : "Off")}, Timeout={timeout}s");
}

// Named parameters
public static void ConfigureDevice(string deviceName, bool enableLogging = false, int timeout = 30)
{
    Console.WriteLine($"Configuring {deviceName}: Logging={(enableLogging ? "On" : "Off")}, Timeout={timeout}s");
}

' Named parameters
Public Shared Sub ConfigureDevice(ByVal deviceName As String, Optional ByVal enableLogging As Boolean = False, Optional ByVal timeout As Integer = 30)
	Console.WriteLine($"Configuring {deviceName}: Logging={(If(enableLogging, "On", "Off"))}, Timeout={timeout}s")
End Sub

' Named parameters
Public Shared Sub ConfigureDevice(ByVal deviceName As String, Optional ByVal enableLogging As Boolean = False, Optional ByVal timeout As Integer = 30)
	Console.WriteLine($"Configuring {deviceName}: Logging={(If(enableLogging, "On", "Off"))}, Timeout={timeout}s")
End Sub

Sie können benannte Parameter verwenden, um Werte außerhalb der Reihenfolge anzugeben oder optionale Parameter zu überspringen.

static void Main()
{
    ConfigureDevice("Router", timeout: 60);
}

static void Main()
{
    ConfigureDevice("Router", timeout: 60);
}

Shared Sub Main()
	ConfigureDevice("Router", timeout:= 60)
End Sub

Shared Sub Main()
	ConfigureDevice("Router", timeout:= 60)
End Sub

Dieser Aufruf verwendet ein optionales Argument, um einen Wert für ein Timeout anzugeben, während der Standardwert für enableLogging verwendet wird.

Kombinieren von festen und optionalen Parametern

Methoden können sowohl erforderliche Parameter (feste Argumente) als auch optionale Parameter enthalten. Erforderliche Parameter müssen in der Methodendeklaration immer den optionalen Parametern vorausgehen, wie im folgenden Code-Snippet zu sehen ist.

Codebeispiel

public static void CreateProfile(string firstName, string lastName, int age = 25, string city = "Unknown")
{
    Console.WriteLine($"Name: {firstName} {lastName}, Age: {age}, City: {city}");
}

public static void CreateProfile(string firstName, string lastName, int age = 25, string city = "Unknown")
{
    Console.WriteLine($"Name: {firstName} {lastName}, Age: {age}, City: {city}");
}

Public Shared Sub CreateProfile(ByVal firstName As String, ByVal lastName As String, Optional ByVal age As Integer = 25, Optional ByVal city As String = "Unknown")
	Console.WriteLine($"Name: {firstName} {lastName}, Age: {age}, City: {city}")
End Sub

Public Shared Sub CreateProfile(ByVal firstName As String, ByVal lastName As String, Optional ByVal age As Integer = 25, Optional ByVal city As String = "Unknown")
	Console.WriteLine($"Name: {firstName} {lastName}, Age: {age}, City: {city}")
End Sub

Aufruf der Methode

static void Main()
{
    CreateProfile("John", "Doe"); // Uses default age and city
    CreateProfile("Jane", "Doe", 30, "New York"); // Specifies all parameters
}

static void Main()
{
    CreateProfile("John", "Doe"); // Uses default age and city
    CreateProfile("Jane", "Doe", 30, "New York"); // Specifies all parameters
}

Shared Sub Main()
	CreateProfile("John", "Doe") ' Uses default age and city
	CreateProfile("Jane", "Doe", 30, "New York") ' Specifies all parameters
End Sub

Shared Sub Main()
	CreateProfile("John", "Doe") ' Uses default age and city
	CreateProfile("Jane", "Doe", 30, "New York") ' Specifies all parameters
End Sub

Diese Flexibilität, Argumente wegzulassen, ermöglicht es, dieselbe Methode in verschiedenen Kontexten zu verwenden, ohne dass mehrere Überladungen erforderlich sind.

Standardwerte müssen konstante Ausdrücke sein

Die Standardparameter für optionale Argumente müssen konstante Ausdrücke sein, die zur Kompilierungszeit ausgewertet werden. Dies gewährleistet, dass die Standardwerte immer stabil und vorhersehbar sind.

Korrekte Verwendung von Standardwerten

public static void SendEmail(string address, string subject = "No Subject", string body = "")
{
    Console.WriteLine($"Sending email to {address}\nSubject: {subject}\nBody: {body}");
}

public static void SendEmail(string address, string subject = "No Subject", string body = "")
{
    Console.WriteLine($"Sending email to {address}\nSubject: {subject}\nBody: {body}");
}

Imports Microsoft.VisualBasic

Public Shared Sub SendEmail(ByVal address As String, Optional ByVal subject As String = "No Subject", Optional ByVal body As String = "")
	Console.WriteLine($"Sending email to {address}" & vbLf & "Subject: {subject}" & vbLf & "Body: {body}")
End Sub

Imports Microsoft.VisualBasic

Public Shared Sub SendEmail(ByVal address As String, Optional ByVal subject As String = "No Subject", Optional ByVal body As String = "")
	Console.WriteLine($"Sending email to {address}" & vbLf & "Subject: {subject}" & vbLf & "Body: {body}")
End Sub

Overloading vs. Optionale Parameter

Während die Methodenüberladung das Erstellen mehrerer Methodensignaturen für verschiedene Anwendungsfälle beinhaltet, ermöglicht die Verwendung optionaler Parameter einer einzigen Methode, verschiedene Szenarien zu bewältigen.

Vergleich durch Code

Überladene Methoden könnten so aussehen:

// Method overloading
public static void Alert(string message)
{
    Console.WriteLine(message);
}

public static void Alert(string message, bool urgent)
{
    if (urgent)
        Console.WriteLine("Urgent: " + message);
    else
        Console.WriteLine(message);
}

// Method overloading
public static void Alert(string message)
{
    Console.WriteLine(message);
}

public static void Alert(string message, bool urgent)
{
    if (urgent)
        Console.WriteLine("Urgent: " + message);
    else
        Console.WriteLine(message);
}

' Method overloading
Public Shared Sub Alert(ByVal message As String)
	Console.WriteLine(message)
End Sub

Public Shared Sub Alert(ByVal message As String, ByVal urgent As Boolean)
	If urgent Then
		Console.WriteLine("Urgent: " & message)
	Else
		Console.WriteLine(message)
	End If
End Sub

' Method overloading
Public Shared Sub Alert(ByVal message As String)
	Console.WriteLine(message)
End Sub

Public Shared Sub Alert(ByVal message As String, ByVal urgent As Boolean)
	If urgent Then
		Console.WriteLine("Urgent: " & message)
	Else
		Console.WriteLine(message)
	End If
End Sub

Eine äquivalente Methode mit optionalen Parametern:

public static void Alert(string message, bool urgent = false)
{
    if (urgent)
        Console.WriteLine("Urgent: " + message);
    else
        Console.WriteLine(message);
}

public static void Alert(string message, bool urgent = false)
{
    if (urgent)
        Console.WriteLine("Urgent: " + message);
    else
        Console.WriteLine(message);
}

Public Shared Sub Alert(ByVal message As String, Optional ByVal urgent As Boolean = False)
	If urgent Then
		Console.WriteLine("Urgent: " & message)
	Else
		Console.WriteLine(message)
	End If
End Sub

Public Shared Sub Alert(ByVal message As String, Optional ByVal urgent As Boolean = False)
	If urgent Then
		Console.WriteLine("Urgent: " & message)
	Else
		Console.WriteLine(message)
	End If
End Sub

C#-Optionale Parameter (Wie sie für Entwickler funktionieren): Abbildung 1 - Ausgabe mit optionalen Parametern

Vorteile der Verwendung optionaler Parameter

Optionale Parameter vereinfachen Methodenoberflächen und reduzieren den Bedarf an zahlreichen Überladungen. Sie machen Methoden flexibler und den Code leichter wartbar und verständlich.

Herausforderungen mit optionalen Parametern

Wenn optionalen Parametern zu viel Bedeutung beigemessen wird, kann dies zu Verwirrung darüber führen, was jede Methode für die ordnungsgemäße Ausführung erwartet und erfordert. Sie können die Absicht der Methode verdecken, insbesondere wenn es viele Parameter gibt oder die Standardwerte nicht selbsterklärend sind.

Bewährte Verfahren

Optionale Parameter einschränken: Optionale Parameter sollten mit Bedacht eingesetzt werden, um übermäßig komplexe Methodensignaturen zu vermeiden.
Benannte Argumente verwenden: Dies verbessert die Verständlichkeit von Methodenaufrufen, insbesondere beim Weglassen bestimmter optionaler Parameter.
Standardwerte dokumentieren: Dokumentieren Sie, was jeder Parameter bewirkt und was die Standardwerte bedeuten, um Missbrauch oder Verwirrung zu vermeiden.

Verwendung von IronPDF mit optionalen Parametern in C#

C#-Optionale Parameter (Wie sie für Entwickler funktionieren): Abbildung 2 - IronPDF

IronPDF ist eine nützliche .NET-Bibliothek, die es Entwicklern erlaubt, PDF-Dokumente direkt in ihren Anwendungen zu erstellen, zu manipulieren und zu rendern. Es konvertiert HTML effizient in PDF für PDF-Konvertierung. Dieses HTML kann verschiedene Formen annehmen, wie HTML-String, HTML-Datei oder URL. Es ist ideal für Anwendungen, die eine dynamische Generierung von PDF-Dokumenten wie Rechnungen, Berichte oder benutzerdefinierten Inhalten erfordern. Mit IronPDF können Entwickler das .NET Framework vollständig nutzen, um PDF-Dateien effizient zu verwalten.

Das herausragende Merkmal von IronPDF ist seine Fähigkeit, HTML mühelos in PDF zu konvertieren, wobei Layouts und Stile erhalten bleiben. Es ist perfekt zur Erstellung von PDFs aus web-basierten Inhalten geeignet, wie Berichte, Rechnungen oder Dokumentationen. Sie können HTML-Dateien, URLs und HTML-Strings damit in PDF-Dateien verwandeln.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        
        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
        
        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
        
        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        
        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");
        
        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");
        
        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()
        
        ' 1. Convert HTML String to PDF
        Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
        Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
        
        ' 2. Convert HTML File to PDF
        Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
        Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
        
        ' 3. Convert URL to PDF
        Dim url = "http://ironpdf.com" ' Specify the URL
        Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
        pdfFromUrl.SaveAs("URLToPDF.pdf")
    End Sub
End Module

Imports IronPdf

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()
        
        ' 1. Convert HTML String to PDF
        Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
        Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")
        
        ' 2. Convert HTML File to PDF
        Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
        Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")
        
        ' 3. Convert URL to PDF
        Dim url = "http://ironpdf.com" ' Specify the URL
        Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
        pdfFromUrl.SaveAs("URLToPDF.pdf")
    End Sub
End Module

Die Kombination von IronPDF mit optionalen C#-Parametern kann den Prozess der PDF-Dokumentenerstellung erleichtern. Durch den Einsatz optionaler Parameter können Entwickler flexible Methoden zur PDF-Erstellung schaffen, die sich mit minimaler Methodenüberladung an unterschiedliche Eingaben und Anforderungen anpassen können.

Codebeispiel

Hier ist ein Beispiel, das zeigt, wie Sie IronPDF zusammen mit optionalen C#-Parametern verwenden können, um einen angepassten PDF-Bericht aus einer einfachen HTML-Vorlage zu erstellen, wobei möglicherweise Details wie der Titel und die Aufnahme bestimmter Berichtsteile angepasst werden:

using IronPdf;
using System;

public class PdfReportGenerator
{
    // Method to generate PDF with optional parameters
    public static void CreatePdfReport(string htmlContent, string filePath = "Report.pdf", bool includeCharts = true, string reportTitle = "Monthly Report")
    {
        // Optional parameters allow customization of the report's title and content dynamically
        var renderer = new ChromePdfRenderer();
        // Customize the PDF document
        renderer.RenderingOptions.TextHeader.CenterText = reportTitle;
        renderer.RenderingOptions.TextFooter.CenterText = "Generated on " + DateTime.Now.ToString("dd-MM-yyyy");
        renderer.RenderingOptions.MarginTop = 50;  // Set the top margin
        renderer.RenderingOptions.MarginBottom = 50;  // Set the bottom margin
        if (!includeCharts)
        {
            // Modify HTML content to remove chart sections if not included
            htmlContent = htmlContent.Replace("<div class='charts'></div>", "");
        }
        // Render the HTML to PDF
        PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the generated PDF to a file
        pdf.SaveAs(filePath);
        Console.WriteLine($"PDF report has been created at {filePath}");
    }

    static void Main()
    {
        License.LicenseKey = "License-Key"; // Specify the license key if required
        string htmlTemplate = @"
        <html>
        <head>
            <title>Monthly Report</title>
        </head>
        <body>
            <h1>Monthly Performance Report</h1>
            <p>This section contains text describing the overall performance for the month.</p>
            <div class='charts'>
                <h2>Sales Charts</h2>
                <!-- Placeholder for charts -->
            </div>
        </body>
        </html>";

        // Call the CreatePdfReport method with different parameters
        CreatePdfReport(htmlTemplate, "BasicReport.pdf", false, "Basic Monthly Report");
        CreatePdfReport(htmlTemplate, "FullReport.pdf", true, "Detailed Monthly Report");
    }
}

using IronPdf;
using System;

public class PdfReportGenerator
{
    // Method to generate PDF with optional parameters
    public static void CreatePdfReport(string htmlContent, string filePath = "Report.pdf", bool includeCharts = true, string reportTitle = "Monthly Report")
    {
        // Optional parameters allow customization of the report's title and content dynamically
        var renderer = new ChromePdfRenderer();
        // Customize the PDF document
        renderer.RenderingOptions.TextHeader.CenterText = reportTitle;
        renderer.RenderingOptions.TextFooter.CenterText = "Generated on " + DateTime.Now.ToString("dd-MM-yyyy");
        renderer.RenderingOptions.MarginTop = 50;  // Set the top margin
        renderer.RenderingOptions.MarginBottom = 50;  // Set the bottom margin
        if (!includeCharts)
        {
            // Modify HTML content to remove chart sections if not included
            htmlContent = htmlContent.Replace("<div class='charts'></div>", "");
        }
        // Render the HTML to PDF
        PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);
        // Save the generated PDF to a file
        pdf.SaveAs(filePath);
        Console.WriteLine($"PDF report has been created at {filePath}");
    }

    static void Main()
    {
        License.LicenseKey = "License-Key"; // Specify the license key if required
        string htmlTemplate = @"
        <html>
        <head>
            <title>Monthly Report</title>
        </head>
        <body>
            <h1>Monthly Performance Report</h1>
            <p>This section contains text describing the overall performance for the month.</p>
            <div class='charts'>
                <h2>Sales Charts</h2>
                <!-- Placeholder for charts -->
            </div>
        </body>
        </html>";

        // Call the CreatePdfReport method with different parameters
        CreatePdfReport(htmlTemplate, "BasicReport.pdf", false, "Basic Monthly Report");
        CreatePdfReport(htmlTemplate, "FullReport.pdf", true, "Detailed Monthly Report");
    }
}

Imports IronPdf
Imports System

Public Class PdfReportGenerator
	' Method to generate PDF with optional parameters
	Public Shared Sub CreatePdfReport(ByVal htmlContent As String, Optional ByVal filePath As String = "Report.pdf", Optional ByVal includeCharts As Boolean = True, Optional ByVal reportTitle As String = "Monthly Report")
		' Optional parameters allow customization of the report's title and content dynamically
		Dim renderer = New ChromePdfRenderer()
		' Customize the PDF document
		renderer.RenderingOptions.TextHeader.CenterText = reportTitle
		renderer.RenderingOptions.TextFooter.CenterText = "Generated on " & DateTime.Now.ToString("dd-MM-yyyy")
		renderer.RenderingOptions.MarginTop = 50 ' Set the top margin
		renderer.RenderingOptions.MarginBottom = 50 ' Set the bottom margin
		If Not includeCharts Then
			' Modify HTML content to remove chart sections if not included
			htmlContent = htmlContent.Replace("<div class='charts'></div>", "")
		End If
		' Render the HTML to PDF
		Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
		' Save the generated PDF to a file
		pdf.SaveAs(filePath)
		Console.WriteLine($"PDF report has been created at {filePath}")
	End Sub

	Shared Sub Main()
		License.LicenseKey = "License-Key" ' Specify the license key if required
		Dim htmlTemplate As String = "
        <html>
        <head>
            <title>Monthly Report</title>
        </head>
        <body>
            <h1>Monthly Performance Report</h1>
            <p>This section contains text describing the overall performance for the month.</p>
            <div class='charts'>
                <h2>Sales Charts</h2>
                <!-- Placeholder for charts -->
            </div>
        </body>
        </html>"

		' Call the CreatePdfReport method with different parameters
		CreatePdfReport(htmlTemplate, "BasicReport.pdf", False, "Basic Monthly Report")
		CreatePdfReport(htmlTemplate, "FullReport.pdf", True, "Detailed Monthly Report")
	End Sub
End Class

Imports IronPdf
Imports System

Public Class PdfReportGenerator
	' Method to generate PDF with optional parameters
	Public Shared Sub CreatePdfReport(ByVal htmlContent As String, Optional ByVal filePath As String = "Report.pdf", Optional ByVal includeCharts As Boolean = True, Optional ByVal reportTitle As String = "Monthly Report")
		' Optional parameters allow customization of the report's title and content dynamically
		Dim renderer = New ChromePdfRenderer()
		' Customize the PDF document
		renderer.RenderingOptions.TextHeader.CenterText = reportTitle
		renderer.RenderingOptions.TextFooter.CenterText = "Generated on " & DateTime.Now.ToString("dd-MM-yyyy")
		renderer.RenderingOptions.MarginTop = 50 ' Set the top margin
		renderer.RenderingOptions.MarginBottom = 50 ' Set the bottom margin
		If Not includeCharts Then
			' Modify HTML content to remove chart sections if not included
			htmlContent = htmlContent.Replace("<div class='charts'></div>", "")
		End If
		' Render the HTML to PDF
		Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
		' Save the generated PDF to a file
		pdf.SaveAs(filePath)
		Console.WriteLine($"PDF report has been created at {filePath}")
	End Sub

	Shared Sub Main()
		License.LicenseKey = "License-Key" ' Specify the license key if required
		Dim htmlTemplate As String = "
        <html>
        <head>
            <title>Monthly Report</title>
        </head>
        <body>
            <h1>Monthly Performance Report</h1>
            <p>This section contains text describing the overall performance for the month.</p>
            <div class='charts'>
                <h2>Sales Charts</h2>
                <!-- Placeholder for charts -->
            </div>
        </body>
        </html>"

		' Call the CreatePdfReport method with different parameters
		CreatePdfReport(htmlTemplate, "BasicReport.pdf", False, "Basic Monthly Report")
		CreatePdfReport(htmlTemplate, "FullReport.pdf", True, "Detailed Monthly Report")
	End Sub
End Class

Hier ist die Vorschau der FullReport-PDF-Datei:

C#-Optionale Parameter (Wie sie für Entwickler funktionieren): Abbildung 3 - PDF-Berichtsausgabe

Die Methode CreatePdfReport im Codebeispiel ist so strukturiert, dass sie PDF-Dokumente aus HTML-Inhalten generiert und mit optionalen Parametern wie dem Dateipfad, der Einbeziehung von Diagrammen und dem Berichtstitel Flexibilität bietet. Dieses Design ermöglicht es der Methode, sich mit minimalen Codeanpassungen an unterschiedliche Berichtsanforderungen anzupassen. Innerhalb der Methode werden die IronPDF-Einstellungen angepasst, um benutzerdefinierte Kopfzeilen und Fußzeilen im PDF einzuschließen, welche den Berichtstitel und das Erstellungsdatum des Berichts anzeigen sollen.

Ränder werden ebenfalls konfiguriert, um das visuelle Layout des Dokuments zu verbessern. Abhängig davon, ob der Parameter includeCharts wahr oder falsch ist, wird der HTML-Inhalt dynamisch verändert, um entweder Diagrammvisualisierungen einzuschließen oder auszuschließen. Zum Schluss wird das möglicherweise modifizierte HTML in ein PDF konvertiert und an einem angegebenen Speicherort gespeichert. Dieses Beispiel demonstriert, wie optionale Parameter den Prozess der Erstellung maßgeschneiderter PDF-Berichte erheblich vereinfachen können.

Abschluss

Zusammenfassend ermöglichen optionale Parameter es Entwicklern, flexibleren und wartungsfreundlicheren Code zu erstellen, indem sie den Bedarf an mehreren überladenen Methoden verringern. Durch die Kombination von C#-optional-Parametern mit der IronPDF-Bibliothek können Entwickler effizient maßgeschneiderte PDF-Dokumente erstellen. Diese Integration vereinfacht nicht nur den Code, sondern erweitert auch die Funktionalität, was die Anpassung an verschiedene Berichterstellungsanforderungen oder Benutzerpräferenzen erleichtert.

IronPDF selbst ist ein leistungsstarkes Werkzeug für jeden .NET-Entwickler, der PDF-Funktionen in seine Anwendungen integrieren möchte, und bietet eine kostenlose IronPDF-Testversion für Entwickler an, die seine Fähigkeiten testen möchten. Für die fortlaufende Nutzung beginnen Lizenzen ab $999 und bieten eine kosteneffiziente Lösung für die professionelle PDF-Bearbeitung.

Jacob Mellor

Jetzt mit dem Ingenieurteam chatten

Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.

...