Czym sa opcjonalne parametry w C# i jak sa używane?

Opcjonalne parametry w C# pozwalają programistom definiowac metody, ktore mogą być wywolywane z mniejsza liczba argumentow, okreslajac wartosci domyslne dla niektorych parametrow. Oznacza to, ze jeśli argument zostanie pominiety w wywolaniu metody, zostanie uzyta wartosc domyslna.

Jak parametry nazwane mogą poprawić czytelnosc kodu w C#?

Parametry nazwane poprawiaja czytelnosc kodu, pozwalając programiscie bezpośrednio w wywolaniu metody okreslic, ktore parametry sa przypisywane. Jest to szczegółnie przydatne przy pracy z metodami posiadajacymi wiele parametrow, poniewaz wyjasnia, ktore argumenty odpowiadają ktorym parametrom.

Jaka jest roznica miedzy parametrami opcjonalnymi a przeciążeniem metody w C#?

Opcjonalne parametry pozwalają pojedynczej metodzie obsługiwac różna liczbe argumentow, podczas gdy przeciazenie metody polega na tworzeniu wielu wersji metody z różnymi parametrami. Opcjonalne parametry redukuja zlozonosc, unikajac wielu definicji metod.

Jak opcjonalne parametry mogą być korzystne przy korzystaniu z biblioteki .NET do generowania PDF?

Przy korzystaniu z biblioteki .NET do generowania PDF opcjonalne parametry mogą uproscic wywolania metod, pozwalając programistom okreslac tylko niezbędne argumenty do generowania plików PDF. Ta elastycznosc pomaga w dostosowywaniu zawartości PDF, ukladu i właściwości pliku bez potrzeby wielu przeciązen.

Jakie są najlepsze praktyki dotyczące używania parametrow opcjonalnych w C#?

Najlepsze praktyki dotyczące używania parametrow opcjonalnych obejmuja ograniczenie ich stosowania, aby uniknąć nieporozumien, zapewnienie dobrze udokumentowanych wartosci domyslnych oraz użycie ich w połączeniu z parametrami nazwanymi w celu poprawy przejrzystosci wywolan metody.

Jak połączenie parametrow stalych i opcjonalnych korzystnie wpływa na projektowanie metod?

Połączenie parametrow stalych i opcjonalnych pozwala programistom wymagac pewnych danych wejsciowych przy jednoczesnym zapewnieniu elastycznosci dla innych. Ta strategia projektowania zapewnia dostarczenie niezbędnych danych przy jednoczesnym uproszczeniu interfejsu metody dla dodatkowych, nieistotnych danych wejsciowych.

Jak można uproscic generowanie raportow PDF za pomoca parametrow opcjonalnych w C#?

Opcjonalne parametry w C# mogą uproscic generowanie raportow PDF, pozwalając programistom okreslac tylko niezbędne dane, takie jak tytuł czy autor, przy stosowaniu wartosci domyslnych dla innych parametrow, takich jak ścieżka pliku czy uklad strony, co redukuje potrzebe wielu wersji metod.

Biblioteka PDF dla C#

Explore IronPDF Bezpłatna próba

HTML do PDF

Online Demo Zobacz wszystkie przykłady kodu %s

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

AKTUALNOŚCI DLA PROGRAMISTÓW

Parametry opcjonalne w języku C# (jak to działa dla programistów)

Jacob Mellor

Updated: 21 kwietnia 2026

Defining Optional Parameters in C#

Podstawowa składnia

Aby zdefiniować opcjonalny parametr, należy przypisać mu wartość domyślną w deklaracji metody. Ta wartość domyślna musi być stałym wyrażeniem. Oto, jak można zdefiniować metodę z jednym lub więcej opcjonalnymi domyślnymi parametrami w definicji metody:

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

W powyższym fragmencie kodu 'end' jest opcjonalnym parametrem z domyślną wartością '!' Pozwala to na wywołanie metody z podanym lub bez drugiego argumentu.

Wywoływanie metod za pomocą opcjonalnych parametrów

Oto dwa sposoby na wywołanie powyższej metody:

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

Pierwsze wywołanie pomija drugi argument, używając wartości domyślnej. Drugie wywołanie podaje określoną wartość, zastępując domyślną.

Wykorzystywanie parametrów nazwanych i opcjonalnych

Nazwane i opcjonalne parametry w C# poprawiają czytelność wywołań metod zawierających opcjonalne parametry. Pozwalają na określenie, które parametry są uzupełniane wartościami, poprzez bezpośrednie ich nazwanie w wywołaniu.

Przykład użycia parametrów nazwanych

// 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

Można użyć parametrów nazwanych, aby określić wartości poza kolejnością lub pominąć opcjonalne parametry.

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

To wywołanie używa opcjonalnego argumentu do określenia wartości dla limitu czasu, podczas gdy używa domyślnej wartości dla enableLogging.

Łączenie parametrów stałych i opcjonalnych

Metody mogą mieć zarówno wymagane parametry (stałe argumenty), jak i parametry opcjonalne. Wymagane parametry zawsze muszą poprzedzać opcjonalne w deklaracji metody, jak pokazano w poniższym fragmencie kodu.

Przykład kodu

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

Wywoływanie metody

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

Ta elastyczność pomijania argumentów pozwala na wykorzystanie tej samej metody w różnych kontekstach bez potrzeby wielu przeciążeń.

Wartości domyślne muszą być stałymi wyrażeniami

Domyślne parametry dla opcjonalnych argumentów muszą być stałymi wyrażeniami, które są oceniane w czasie kompilacji. To zapewnia stabilność i przewidywalność wartości domyślnych.

Prawidłowe użycie wartości domyślnych

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

Przeciążenie vs parametry opcjonalne

Podczas gdy przeciążenie metod polega na tworzeniu wielu sygnatur metod dla różnych przypadków użycia, wykorzystanie opcjonalnych parametrów pozwala jednej metodzie obsłużyć różne scenariusze.

Porównanie przez kod

Metody przeciążone mogą wyglądać tak:

// 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

Równoważna metoda używająca opcjonalnych parametrów:

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# Opcjonalne parametry (jak to działa dla deweloperów): Rysunek 1 - Wynik opcjonalnego parametru

Zalety korzystania z opcji opcjonalnych parametrów

Opcjonalne parametry upraszczają interfejsy metod i zmniejszają potrzebę licznych przeciążeń. Umożliwiają większą elastyczność metod i ułatwiają utrzymanie oraz zrozumienie kodu.

Wyzwania związane z opcjonalnymi parametrami

Jeśli są nadużywane, opcjonalne parametry mogą prowadzić do zamieszania co do tego, co każda metoda oczekuje i wymaga dla prawidłowego działania. Mogą zniekształcać intencję metody, zwłaszcza gdy jest wiele parametrów lub gdy wartości domyślne nie są samoobjaśniające.

Najlepsze praktyki

Ogranicz parametry opcjonalne: Używaj opcjonalnych parametrów z rozwagą, aby unikać nadmiernie skomplikowanych sygnatur metod.
Używaj argumentów nazwanych: Zwiększ przejrzystość wywołań metod, szczególnie gdy pomijasz niektóre opcjonalne parametry.
Dokumentuj wartości domyślne: Dokumentuj, co robi każdy parametr i co implikują wartości domyślne, aby zapobiec nadużyciu lub zamieszaniu.

Wykorzystywanie IronPDF z opcjonalnymi parametrami C#

C# Opcjonalne parametry (jak to działa dla deweloperów): Rysunek 2 - IronPDF

IronPDF to przydatna biblioteka .NET, która pozwala deweloperom tworzyć, manipulować i renderować dokumenty PDF bezpośrednio w ich aplikacjach. Skutecznie konwertuje HTML na PDF dla konwersji PDF. Ten HTML może przybrać różne formy, takie jak łańcuch HTML, plik HTML lub URL. Jest idealny dla aplikacji, które wymagają dynamicznego generowania dokumentów PDF, takich jak faktury, raporty lub dostosowane treści użytkowników. Dzięki IronPDF deweloperzy mogą w pełni wykorzystać platformę .NET do efektywnego zarządzania plikami PDF.

Wyróżniającą się cechą IronPDF jest jego zdolność do prostego konwertowania HTML na PDF, co zachowuje układy i style. Jest doskonałym narzędziem do tworzenia PDF-ów z treści opartych na sieci, takich jak raporty, faktury lub dokumentacja. Można za jego pomocą konwertować pliki HTML, URL oraz łańcuchy HTML na pliki 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");
    }
}

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

Łączenie IronPDF z opcjonalnymi parametrami C# może uczynić proces generowania dokumentów PDF łatwiejszym. Wykorzystując opcjonalne parametry, deweloperzy mogą tworzyć elastyczne metody generowania PDF, które mogą się dostosować do różnych danych wejściowych i wymagań przy minimalnych przeciążeniach.

Przykład kodu

Oto przykład pokazujący, jak można użyć IronPDF w połączeniu z opcjonalnymi parametrami C#, aby wygenerować dostosowany raport PDF z prostego szablonu HTML, potencjalnie dostosowując takie szczegóły jak tytuł oraz, czy uwzględnić pewne sekcje raportu:

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

Oto podgląd pliku PDF FullReport:

C# Opcjonalne parametry (jak to działa dla deweloperów): Rysunek 3 - Wynik raportu PDF

Metoda CreatePdfReport w przykładzie kodu jest skonstruowana tak, aby generować dokumenty PDF z treści HTML, oferując elastyczność dzięki opcjonalnym parametrom takim jak ścieżka pliku, uwzględnienie wykresów oraz tytuł raportu. Ten projekt pozwala metodzie dostosować się do różnych potrzeb raportowania przy niewielkich korektach kodu. W obrębie metody ustawienia IronPDF są dostosowywane do uwzględnienia niestandardowych nagłówków i stopki w PDF, które są ustawione na wyświetlanie tytułu raportu i daty jego wygenerowania.

Marginesy są również skonfigurowane, aby poprawić wizualny układ dokumentu. W zależności od tego, czy parametr includeCharts jest prawdziwy czy fałszywy, treść HTML jest dynamicznie modyfikowana, aby uwzględniać lub wykluczać wykresy. Na koniec potencjalnie zmodyfikowany HTML jest konwertowany na PDF i zapisywany w określonym miejscu. Ten przykład pokazuje, jak opcjonalne parametry mogą znacznie uprościć proces tworzenia dostosowanych raportów PDF.

Wnioski

C# Opcjonalne parametry (jak to działa dla deweloperów): Rysunek 4 - Licencjonowanie

Podsumowując, opcjonalne parametry pozwalają deweloperom tworzyć bardziej elastyczny i łatwiejszy w utrzymaniu kod, zmniejszając potrzebę wielu przeciążeń metod. Łącząc opcjonalne parametry C# z biblioteką IronPDF, deweloperzy mogą skutecznie generować dostosowane dokumenty PDF. To rozwiązanie nie tylko upraszcza kod, ale także zwiększa funkcjonalność, co ułatwia dostosowanie się do różnych wymagań raportowania lub preferencji użytkowników.

Sam IronPDF to potężne narzędzie dla każdego dewelopera .NET, które pozwala na integrację funkcjonalności PDF w swoich aplikacjach, oferując bezpłatną licencję próbną IronPDF dla deweloperów, którzy chcą przetestować jego możliwości. Dla ciągłego użytkowania licencje zaczynają się od $999, oferując opłacalne rozwiązanie do profesjonalnej manipulacji PDF.

Jacob Mellor

Czat z zespołem inżynierów teraz

Dyrektor ds. technologii

Jacob Mellor jest Chief Technology Officer w Iron Software i wizjonerskim inżynierem, pionierem technologii C# PDF. Jako pierwotny deweloper głównej bazy kodowej Iron Software, kształtuje architekturę produktów firmy od jej początku, przekształcając ją wspólnie z CEO Cameron Rimington w firmę liczącą ponad 50 osób, obsługującą NASA, Teslę i światowe agencje rządowe.

...

Czytaj więcej