¿Cuáles son los parámetros opcionales en C# y cómo se utilizan?

Los parámetros opcionales en C# permiten a los desarrolladores definir métodos que pueden ser llamados con menos argumentos al especificar valores predeterminados para algunos parámetros. Esto significa que si se omite un argumento en la llamada al método, se utiliza el valor predeterminado.

¿Cómo pueden los parámetros nombrados mejorar la legibilidad del código en C#?

Los parámetros nombrados mejoran la legibilidad del código al permitir que el desarrollador especifique qué parámetros se están asignando directamente en la llamada al método. Esto es particularmente útil al tratar con métodos que tienen múltiples parámetros, ya que aclara qué argumentos corresponden a qué parámetros.

¿Cuál es la diferencia entre los parámetros opcionales y la sobrecarga de métodos en C#?

Los parámetros opcionales permiten que un solo método maneje diferentes números de argumentos, mientras que la sobrecarga de métodos implica crear múltiples versiones de un método con diferentes parámetros. Los parámetros opcionales reducen la complejidad al evitar múltiples definiciones de métodos.

¿Cómo pueden ser beneficiosos los parámetros opcionales al usar una biblioteca .NET para la generación de PDF?

Al utilizar una biblioteca .NET para la generación de PDF, los parámetros opcionales pueden simplificar las llamadas a métodos al permitir a los desarrolladores especificar solo los argumentos necesarios para generar PDF. Esta flexibilidad ayuda a personalizar el contenido del PDF, el diseño y las propiedades del archivo sin necesitar múltiples sobrecargas.

¿Cuáles son las mejores prácticas para usar parámetros opcionales en C#?

Las mejores prácticas para usar parámetros opcionales incluyen limitar su uso para evitar confusiones, garantizar que los valores predeterminados estén bien documentados y usarlos junto con parámetros nombrados para mejorar la claridad de las llamadas a métodos.

¿Cómo beneficia a la creación de métodos combinar parámetros fijos y opcionales?

Combinar parámetros fijos y opcionales permite a los desarrolladores exigir ciertos datos de entrada y al mismo tiempo proporcionar flexibilidad para otros. Esta estrategia de diseño garantiza que se proporcione la información necesaria al tiempo que se simplifica la interfaz del método para entradas adicionales y no esenciales.

¿Cómo puedes simplificar la generación de informes en PDF con parámetros opcionales en C#?

Los parámetros opcionales en C# pueden agilizar la generación de informes en PDF al permitir a los desarrolladores especificar solo los datos necesarios, como el título o el autor, mientras usan configuraciones predeterminadas para otros parámetros como la ruta del archivo o el diseño de la página, reduciendo así la necesidad de múltiples versiones de los métodos.

La Biblioteca PDF de C#

Explore IronPDF Prueba gratis

HTML a PDF

Online Demo Ver Todos los Ejemplos de Código %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

ACTUALIZACIONES PARA DESARROLLADORES

C# Parámetros Opcionales (Cómo Funciona para Desarrolladores)

Jacob Mellor

Updated: 21 de abril de 2026

Defining Optional Parameters in C#

Sintaxis básica

Para definir un parámetro opcional, le asignas un valor por defecto en la declaración del método. Este valor por defecto debe ser una expresión constante. Aquí está cómo puedes definir un método con uno o más parámetros opcionales por defecto en la definición del método:

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

En el fragmento de código anterior, 'end' es un parámetro opcional con un valor por defecto de '!'. Esto permite que el método sea llamado con o sin proporcionar un segundo argumento.

Llamadas a métodos con parámetros opcionales

Aquí hay dos maneras de llamar al método anterior:

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

La primera llamada omite el segundo argumento, utilizando el valor por defecto. La segunda llamada proporciona un valor específico, sobrescribiendo el valor por defecto.

Utilización de parámetros con nombre y opcionales

Los parámetros nombrados y opcionales en C# mejoran la claridad de las llamadas a métodos que involucran parámetros opcionales. Permiten especificar qué parámetros están recibiendo valores nombrándolos directamente en la llamada.

Ejemplo de uso de parámetros con nombre

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

Puedes usar parámetros nombrados para especificar valores fuera de orden o para omitir parámetros opcionales.

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

Esta llamada utiliza un argumento opcional para especificar un valor para un tiempo de espera mientras utiliza el valor por defecto para enableLogging.

Combinación de parámetros fijos y opcionales

Los métodos pueden tener tanto parámetros requeridos (argumentos fijos) como parámetros opcionales. Los parámetros requeridos siempre deben preceder a los opcionales en la declaración del método, como se puede ver en el siguiente fragmento de código.

Ejemplo de código

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

Llamando al método

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

Esta flexibilidad para omitir argumentos permite que el mismo método sea usado en diferentes contextos sin necesidad de múltiples sobrecargas.

Los valores por defecto deben ser expresiones constantes

Los parámetros por defecto para argumentos opcionales deben ser expresiones constantes, que se evalúan en tiempo de compilación. Esto asegura que los valores por defecto sean siempre estables y previsibles.

Uso correcto de valores por defecto

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

Sobrecarga frente a parámetros opcionales

Mientras que la sobrecarga de métodos implica crear múltiples firmas de método para diferentes casos de uso, el uso de parámetros opcionales permite que un solo método maneje varios escenarios.

Comparación a través del código

Los métodos sobrecargados podrían verse así:

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

Un método equivalente usando parámetros opcionales:

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

Parámetros opcionales en C# (Cómo funciona para los desarrolladores): Figura 1 - Salida de Parámetro Opcional

Beneficios del uso de parámetros opcionales

Los parámetros opcionales simplifican las interfaces de los métodos y reducen la necesidad de numerosas sobrecargas. Hacen que los métodos sean más flexibles y la base de código más fácil de mantener y entender.

Desafíos con parámetros opcionales

Si se utilizan en exceso, los parámetros opcionales pueden llevar a confusión sobre qué espera y requiere cada método para ejecutarse correctamente. Pueden oscurecer la intención del método, especialmente cuando hay muchos parámetros o cuando los valores por defecto no son autoexplicativos.

Bestes prácticas

Limite los parámetros opcionales: utilice los parámetros opcionales con cuidado para evitar firmas de métodos demasiado complejas.
Utilice argumentos con nombre: mejore la claridad en las llamadas a métodos, especialmente al omitir ciertos parámetros opcionales.
Documentar valores predeterminados: documente lo que hace cada parámetro y lo que implican los valores predeterminados para evitar mal uso o confusión.

Utilizando IronPDF con parámetros opcionales de C#

Parámetros opcionales en C# (Cómo funciona para los desarrolladores): Figura 2 - IronPDF

IronPDF es una útil biblioteca .NET que permite a los desarrolladores crear, manipular y renderizar documentos PDF directamente dentro de sus aplicaciones. Convierte HTML a PDF de manera eficiente para la conversión de PDF. Este HTML puede estar en varias formas como cadena HTML, archivo HTML o URL. Es ideal para aplicaciones que requieren la generación dinámica de documentos PDF, como facturas, informes o contenido personalizado de usuario. Con IronPDF, los desarrolladores pueden utilizar completamente el .NET Framework para manejar archivos PDF eficientemente.

La característica destacada de IronPDF es su capacidad de convertir HTML a PDF sin esfuerzo, lo que conserva diseños y estilos. Es perfecto para producir PDFs a partir de contenido basado en la web, como informes, facturas o documentación. Puedes convertir archivos HTML, URLs y cadenas HTML en archivos PDF con él.

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

Combinar IronPDF con parámetros opcionales en C# puede hacer que el proceso de generación de documentos PDF sea fácil. Al utilizar parámetros opcionales, los desarrolladores pueden crear métodos flexibles para la generación de PDF que pueden adaptarse a entradas y requerimientos variables con mínimas sobrecargas de método.

Ejemplo de código

Aquí hay un ejemplo que demuestra cómo puedes usar IronPDF junto con parámetros opcionales en C# para generar un informe PDF personalizado a partir de una simple plantilla HTML, ajustando potencialmente detalles como el título y si incluir ciertas secciones del informe:

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

Aquí está la vista previa del archivo PDF FullReport:

Parámetros opcionales en C# (Cómo funciona para los desarrolladores): Figura 3 - Salida del Informe PDF

El método CreatePdfReport en el ejemplo de código está estructurado para generar documentos PDF a partir de contenido HTML, ofreciendo flexibilidad con parámetros opcionales como la ruta del archivo, la inclusión de gráficos, y el título del informe. Este diseño permite que el método se adapte a diferentes necesidades de informes con ajustes mínimos de código. Dentro del método, se ajustan configuraciones de IronPDF para incluir encabezados y pies de página personalizados en el PDF, que están configurados para mostrar el título del informe y la fecha en que se generó el informe.

También se configuran márgenes para mejorar el diseño visual del documento. Dependiendo de si el parámetro includeCharts es verdadero o falso, el contenido HTML se modifica dinámicamente para incluir o excluir visuales de gráficos. Finalmente, el HTML potencialmente modificado se convierte en un PDF y se guarda en una ubicación específica. Este ejemplo demuestra cómo los parámetros opcionales pueden simplificar significativamente el proceso de creación de informes PDF a medida.

Conclusión

Parámetros opcionales en C# (Cómo funciona para los desarrolladores): Figura 4 - Licencias

En conclusión, los parámetros opcionales permiten a los desarrolladores crear código más flexible y mantenible al reducir la necesidad de múltiples métodos sobrecargados. Combinando parámetros opcionales en C# con la biblioteca IronPDF, los desarrolladores pueden generar eficientemente documentos PDF personalizados. Esta integración no solo simplifica la base de código, sino que también mejora la funcionalidad, haciendo más fácil adaptarse a diferentes requerimientos de informes o preferencias del usuario.

IronPDF en sí mismo es una herramienta poderosa para cualquier desarrollador .NET que busque incorporar funcionalidades de PDF en sus aplicaciones, ofreciendo una prueba gratuita de IronPDF para desarrolladores para aquellos que deseen probar sus capacidades. Para uso continuo, las licencias comienzan desde $999, proporcionando una solución rentable para la manipulación de PDF de calidad profesional.

Jacob Mellor

Chat with engineering team now

Chief Technology Officer

Jacob Mellor is Chief Technology Officer at Iron Software and a visionary engineer pioneering C# PDF technology. As the original developer behind Iron Software's core codebase, he has shaped the company's product architecture since its inception, transforming it alongside CEO Cameron Rimington into a 50+ person company serving NASA, Tesla, and global government agencies.

...