¿Cuáles son las nuevas características introducidas en C# 12?

C# 12 introduce Constructores Primarios, interceptores y expresiones de colección, que juntos proporcionan opciones de sintaxis más concisas y potentes para los desarrolladores.

¿Pueden usarse los Constructores Primarios con estructuras de datos inmutables?

Sí, los Constructores Primarios son adecuados para estructuras de datos inmutables ya que permiten la inicialización de propiedades de solo lectura directamente dentro del constructor.

¿Cómo puedo convertir contenido HTML en un PDF usando C#?

Puedes usar la clase ChromePdfRenderer de IronPDF para convertir contenido HTML a PDF, asegurando que el formato y el estilo se preserven en el documento de salida.

¿Cuáles son las ventajas de usar IronPDF para la generación de PDFs?

IronPDF proporciona una plataforma robusta para crear y manipular archivos PDF en C#, soportando características como la conversión de HTML a PDF, la fusión de PDFs y la preservación detallada del estilo.

¿Cómo mejoran los Constructores Primarios la inyección de dependencias?

Los Constructores Primarios mejoran la inyección de dependencias al indicar claramente las dependencias de clase en los parámetros del constructor, lo que simplifica la configuración y el mantenimiento del gráfico de dependencias.

¿Cómo pueden integrarse los Constructores Primarios con la generación de documentos PDF?

Los Constructores Primarios pueden usarse para inicializar clases de configuración o estructuras asociadas con configuraciones de PDF al utilizar una biblioteca como IronPDF, simplificando el proceso de configuración.

¿Cuáles son algunos ejemplos prácticos de los Constructores Primarios en acción?

Los ejemplos prácticos incluyen la inicialización de jerarquías de formas geométricas y escenarios de inyección de dependencias donde la claridad y la concisión son esenciales.

¿Cómo pueden los desarrolladores comenzar a usar IronPDF en sus proyectos?

Los desarrolladores pueden instalar el paquete NuGet de IronPDF a través de la Consola del Administrador de Paquetes o el Administrador de Paquetes NuGet y consultar la documentación completa para detalles de implementación.

¿Qué papel juega IronPDF en los flujos de trabajo de generación de documentos?

IronPDF mejora los flujos de trabajo de generación de documentos al permitir que los desarrolladores creen, conviertan y manipulen PDFs fácilmente en C#, soportando la integración sin problemas con otras características de C#.

La Biblioteca PDF de C#

Q: ¿Cómo hacen los Constructores Primarios más conciso el código de C#?

Los Constructores Primarios te permiten declarar e inicializar propiedades directamente dentro de la declaración de la clase, reduciendo la cantidad de código repetitivo y mejorando la legibilidad.

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

Install-Package IronPdf

ACTUALIZACIONES PARA DESARROLLADORES

Constructor principal C# (Cómo funciona para desarrolladores)

Jacob Mellor

Updated: 4 de septiembre de 2026

En el paisaje orientado a objetos de la programación C#, la introducción de Constructores Primarios trae un nuevo nivel de elegancia y simplicidad al lenguaje. Los constructores primarios, junto a características como interceptores y expresiones de colección, surgieron en C# 12 como una poderosa característica, ofreciendo una sintaxis más concisa para declarar constructores con parámetros. Puedes explorar en profundidad los constructores primarios en la guía de Microsoft C#.

En este artículo, aprenderemos cómo usar los Constructores Primarios de C# 12 de manera eficiente, explorando también su funcionalidad, casos de uso y cómo transforman la forma en que los desarrolladores abordan la inicialización de clases.

Understanding the Basics: Constructors in C#

Los constructores juegan un papel fundamental en la programación orientada a objetos, sirviendo como el plano para inicializar objetos. Tradicionalmente, los desarrolladores de C# han usado el constructor por defecto o constructores con parámetros para configurar el estado inicial de sus clases. Sin embargo, la introducción de Constructores Primarios añade un enfoque más simplificado a este aspecto esencial del desarrollo en C#.

La esencia de los constructores primarios

Un Constructor Primario en C# es una forma concisa de declarar e inicializar propiedades directamente dentro de la declaración de la clase. Simplifica el proceso de definir y asignar valores a las propiedades, ofreciendo una sintaxis más declarativa y legible.

Beneficios de los constructores primarios

Concisión: Los constructores primarios proporcionan una sintaxis sucinta, reduciendo código repetitivo y mejorando la legibilidad.
Alcance: A diferencia de los constructores tradicionales, los parámetros en los constructores primarios están en alcance a lo largo de toda la clase o estructura, ofreciendo flexibilidad en su uso.
Valores Predeterminados: Los valores predeterminados de los parámetros simplifican la creación de objetos, haciéndolo más conveniente para los desarrolladores.

Declaración de un constructor primario

La sintaxis para un Constructor Primario implica declarar las propiedades directamente en el encabezado de la clase. Consideremos un ejemplo de clase Person básico:

public class Person(string name, int age)
{
    public string Name { get; } = name;
    public int Age { get; } = age;
    public override string ToString() => $"Name: {Name}, Age: {Age}";
}

public class Person(string name, int age)
{
    public string Name { get; } = name;
    public int Age { get; } = age;
    public override string ToString() => $"Name: {Name}, Age: {Age}";
}

Public Class Person(String name, Integer age)
	Public ReadOnly Property Name() As String = name
	Public ReadOnly Property Age() As Integer = age
	Public Overrides Function ToString() As String
		Return $"Name: {Name}, Age: {Age}"
	End Function
End Class

Public Class Person(String name, Integer age)
	Public ReadOnly Property Name() As String = name
	Public ReadOnly Property Age() As Integer = age
	Public Overrides Function ToString() As String
		Return $"Name: {Name}, Age: {Age}"
	End Function
End Class

En el fragmento de código anterior, la clase Person tiene un Constructor Primario que inicializa las propiedades de miembro de instancia Name y Age. Los parámetros del constructor se declaran con el nombre de la clase o estructura, y al momento de definir propiedades públicas, los valores de los parámetros se les asignan.

Ejemplo 1: Punto inmutable en un espacio 2D

public readonly struct Point(double x, double y)
{
    public double X { get; } = x;
    public double Y { get; } = y;
    public double Magnitude => Math.Sqrt(X * X + Y * Y);
}

public readonly struct Point(double x, double y)
{
    public double X { get; } = x;
    public double Y { get; } = y;
    public double Magnitude => Math.Sqrt(X * X + Y * Y);
}

'INSTANT VB WARNING: VB has no equivalent to the C# readonly struct:
'ORIGINAL LINE: public readonly struct Point(double x, double y)
Public Structure Point(Double x, Double y)
	Public ReadOnly Property X() As Double = x
	Public ReadOnly Property Y() As Double = y
	Public ReadOnly Property Magnitude() As Double
		Get
			Return Math.Sqrt(X * X + Y * Y)
		End Get
	End Property
End Structure

'INSTANT VB WARNING: VB has no equivalent to the C# readonly struct:
'ORIGINAL LINE: public readonly struct Point(double x, double y)
Public Structure Point(Double x, Double y)
	Public ReadOnly Property X() As Double = x
	Public ReadOnly Property Y() As Double = y
	Public ReadOnly Property Magnitude() As Double
		Get
			Return Math.Sqrt(X * X + Y * Y)
		End Get
	End Property
End Structure

En este ejemplo, el constructor primario para la estructura Point inicializa las propiedades X y Y, mostrando cuán concisa y expresiva puede ser la sintaxis.

Ejemplo 2: Registrador configurable con ajustes predeterminados

public class Logger(string filePath = "log.txt", LogLevel level = LogLevel.Info)
{
    private readonly string _filePath = filePath;
    private readonly LogLevel _level = level;

    public void Log(string message)
    {
        // Actual logging implementation using _filePath and _level
    }
}

public class Logger(string filePath = "log.txt", LogLevel level = LogLevel.Info)
{
    private readonly string _filePath = filePath;
    private readonly LogLevel _level = level;

    public void Log(string message)
    {
        // Actual logging implementation using _filePath and _level
    }
}

'INSTANT VB TODO TASK: The following line contains an assignment within expression that was not extracted by Instant VB:
'ORIGINAL LINE: public class Logger(string filePath = "log.txt", LogLevel level = LogLevel.Info)
Public Class Logger(String filePath = "log.txt", LogLevel level = LogLevel.Info)
	Private ReadOnly _filePath As String = filePath
	Private ReadOnly _level As LogLevel = level

	Public Sub Log(ByVal message As String)
		' Actual logging implementation using _filePath and _level
	End Sub
End Class

'INSTANT VB TODO TASK: The following line contains an assignment within expression that was not extracted by Instant VB:
'ORIGINAL LINE: public class Logger(string filePath = "log.txt", LogLevel level = LogLevel.Info)
Public Class Logger(String filePath = "log.txt", LogLevel level = LogLevel.Info)
	Private ReadOnly _filePath As String = filePath
	Private ReadOnly _level As LogLevel = level

	Public Sub Log(ByVal message As String)
		' Actual logging implementation using _filePath and _level
	End Sub
End Class

Aquí, el constructor primario para la clase Logger proporciona valores predeterminados para filePath y level, haciéndolo flexible y fácil de usar mientras se mantiene la configurabilidad.

Ejemplo 3: Inyección de dependencias

public interface IService
{
    Distance GetDistance();
}

public class ExampleController(IService service) : ControllerBase
{
    public ActionResult<Distance> Get() => service.GetDistance();
}

public interface IService
{
    Distance GetDistance();
}

public class ExampleController(IService service) : ControllerBase
{
    public ActionResult<Distance> Get() => service.GetDistance();
}

Public Interface IService
	Function GetDistance() As Distance
End Interface

Public Class ExampleController(IService service)
	Inherits ControllerBase

	Public Function [Get]() As ActionResult(Of Distance)
		Return service.GetDistance()
	End Function
End Class

Public Interface IService
	Function GetDistance() As Distance
End Interface

Public Class ExampleController(IService service)
	Inherits ControllerBase

	Public Function [Get]() As ActionResult(Of Distance)
		Return service.GetDistance()
	End Function
End Class

Los constructores primarios son ideales para escenarios de inyección de dependencias. En este ejemplo, una clase controlador indica sus dependencias, mejorando el mantenimiento y facilitando las pruebas unitarias.

Ejemplo 4: Construcción de una jerarquía de formas geométricas

public abstract class Shape(double width, double height)
{
    public double Width { get; } = width;
    public double Height { get; } = height;
    public abstract double CalculateArea();
}

public class Rectangle(double width, double height) : Shape(width, height)
{
    public override double CalculateArea() => Width * Height;
}

public class Circle : Shape
{
    public Circle(double radius) : base(radius * 2, radius * 2) { }
    public override double CalculateArea() => Math.PI * Math.Pow(Width / 2, 2);
}

public abstract class Shape(double width, double height)
{
    public double Width { get; } = width;
    public double Height { get; } = height;
    public abstract double CalculateArea();
}

public class Rectangle(double width, double height) : Shape(width, height)
{
    public override double CalculateArea() => Width * Height;
}

public class Circle : Shape
{
    public Circle(double radius) : base(radius * 2, radius * 2) { }
    public override double CalculateArea() => Math.PI * Math.Pow(Width / 2, 2);
}

Public MustInherit Class Shape(Double width, Double height)
	Public ReadOnly Property Width() As Double = width
	Public ReadOnly Property Height() As Double = height
	Public MustOverride Function CalculateArea() As Double
End Class

Public Class Rectangle(Double width, Double height)
	Inherits Shape(width, height)

	Public Overrides Function CalculateArea() As Double
		Return Width * Height
	End Function
End Class

Public Class Circle
	Inherits Shape

	Public Sub New(ByVal radius As Double)
		MyBase.New(radius * 2, radius * 2)
	End Sub
	Public Overrides Function CalculateArea() As Double
		Return Math.PI * Math.Pow(Width / 2, 2)
	End Function
End Class

Public MustInherit Class Shape(Double width, Double height)
	Public ReadOnly Property Width() As Double = width
	Public ReadOnly Property Height() As Double = height
	Public MustOverride Function CalculateArea() As Double
End Class

Public Class Rectangle(Double width, Double height)
	Inherits Shape(width, height)

	Public Overrides Function CalculateArea() As Double
		Return Width * Height
	End Function
End Class

Public Class Circle
	Inherits Shape

	Public Sub New(ByVal radius As Double)
		MyBase.New(radius * 2, radius * 2)
	End Sub
	Public Overrides Function CalculateArea() As Double
		Return Math.PI * Math.Pow(Width / 2, 2)
	End Function
End Class

En este ejemplo, el constructor primario en la clase Shape forma la base para una jerarquía de formas geométricas. Subclases como Rectangle y Circle aprovechan el constructor primario para una inicialización consistente. La clase Rectangle declara el constructor primario y pasa los parámetros del constructor primario capturados a los parámetros primarios de la clase Shape. La clase Circle muestra flexibilidad al definir su constructor dentro de toda la clase y luego pasar sus parámetros como valores predeterminados para el constructor de Shape usando la palabra clave base.

Presentando IronPDF

IronPDF es una biblioteca versátil de C# que permite a los desarrolladores crear, manipular y convertir archivos PDF sin esfuerzo. Ya sea que estés generando facturas, informes u otro documento, IronPDF te permite convertir contenido HTML en PDFs profesionales y pulidos directamente en tu aplicación C#.

IronPDF es una herramienta útil para los desarrolladores que les permite convertir páginas web, URLs y HTML a PDF. La mejor parte es que los PDFs lucen igual que las páginas web originales, preservando todo el formato y estilo. Es perfecto para crear PDFs a partir de contenido web como informes y facturas.

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

Friend Class Program
	Shared Sub Main(ByVal 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 Class

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal 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 Class

Constructor primario de C# (Cómo funciona para el desarrollador): Figura 1 - Página web de IronPDF

Instalación de IronPDF: Un comienzo rápido

Ejecuta el siguiente comando en tu Consola del Administrador de Paquetes: Alternativamente, busca 'IronPDF' en NuGet y procede con la instalación.

PM > Install-Package IronPdf

Install-Package IronPdf

Crear un PDF usando IronPDF es un proceso sencillo.

Constructor primario de C# (Cómo funciona para el desarrollador): Figura 2 - Buscando el paquete IronPDF en el navegador del administrador de paquetes NuGet

Generación de PDF con IronPDF

Crear un PDF usando IronPDF es un proceso simplificado. Considera el siguiente ejemplo:

var htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";
// Create a new PDF document
var pdfDocument = new IronPdf.ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf");

var htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";
// Create a new PDF document
var pdfDocument = new IronPdf.ChromePdfRenderer();
pdfDocument.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf");

Dim htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>"
' Create a new PDF document
Dim pdfDocument = New IronPdf.ChromePdfRenderer()
pdfDocument.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf")

Dim htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>"
' Create a new PDF document
Dim pdfDocument = New IronPdf.ChromePdfRenderer()
pdfDocument.RenderHtmlAsPdf(htmlContent).SaveAs("C:/GeneratedDocument.pdf")

Visita este recurso Explora Ejemplos de Código de IronPDF para más métodos de crear documentos PDF. Para más detalles sobre la creación y manipulación de PDFs en C#, por favor visita este completo enlace de tutorial, y para explorar más, por favor visita esta página de documentación.

Constructores Primarios de C#: Una Revolución en la Inicialización de Clases

Los constructores primarios de C# ofrecen un enfoque declarativo y simplificado para inicializar propiedades de clase directamente dentro de la declaración de la clase. Exploremos si esta elegante característica puede integrarse sin problemas con IronPDF.

Integración de los Constructores Primarios de C# con IronPDF

Mientras que los Constructores Primarios de C# son principalmente una característica del lenguaje enfocada en la inicialización de clases, su integración directa con IronPDF puede no ser un caso de uso común. La funcionalidad central de IronPDF radica en la generación y manipulación de documentos PDF, y los detalles de la inicialización de clases podrían no alinearse directamente con este flujo de trabajo.

Sin embargo, los desarrolladores pueden utilizar Constructores Primarios de C# al definir clases o estructuras personalizadas relacionadas con configuraciones o modelos de datos de IronPDF. Por ejemplo, si tu aplicación requiere una estructura de clase específica para gestionar configuraciones o ajustes relacionados con PDFs, los Constructores Primarios de C# pueden ser una herramienta valiosa para inicializar estas clases concisamente.

public class PdfGenerationSettings(string title, bool includeHeader, bool includeFooter)
{
    public string Title { get; } = title;
    public bool IncludeHeader { get; } = includeHeader;
    public bool IncludeFooter { get; } = includeFooter;
    // Additional properties...
}

// Usage with IronPDF
var pdfSettings = new PdfGenerationSettings("My PDF Title", true, false);
var renderOptions = new ChromePdfRenderOptions
{
    PaperSize = IronPdf.Rendering.PdfPaperSize.A4,
    MarginTop = 20,
    MarginBottom = 20,
    MarginLeft = 10,
    MarginRight = 10,
    Title = pdfSettings.Title
};
// Apply settings from PdfGenerationSettings
if (pdfSettings.IncludeHeader)
{
    renderOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        DrawDividerLine = true
    };
}
var pdfDocument = new IronPdf.ChromePdfRenderer();
pdfDocument.RenderingOptions = renderOptions;
pdfDocument.RenderHtmlAsPdf("<html><body><h1>Hello, IronPDF!</h1></body></html>").SaveAs("CustomizedDocument.pdf");

public class PdfGenerationSettings(string title, bool includeHeader, bool includeFooter)
{
    public string Title { get; } = title;
    public bool IncludeHeader { get; } = includeHeader;
    public bool IncludeFooter { get; } = includeFooter;
    // Additional properties...
}

// Usage with IronPDF
var pdfSettings = new PdfGenerationSettings("My PDF Title", true, false);
var renderOptions = new ChromePdfRenderOptions
{
    PaperSize = IronPdf.Rendering.PdfPaperSize.A4,
    MarginTop = 20,
    MarginBottom = 20,
    MarginLeft = 10,
    MarginRight = 10,
    Title = pdfSettings.Title
};
// Apply settings from PdfGenerationSettings
if (pdfSettings.IncludeHeader)
{
    renderOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        DrawDividerLine = true
    };
}
var pdfDocument = new IronPdf.ChromePdfRenderer();
pdfDocument.RenderingOptions = renderOptions;
pdfDocument.RenderHtmlAsPdf("<html><body><h1>Hello, IronPDF!</h1></body></html>").SaveAs("CustomizedDocument.pdf");

Public Class PdfGenerationSettings(String title, Boolean includeHeader, Boolean includeFooter)
	Public ReadOnly Property Title() As String = title
	Public ReadOnly Property IncludeHeader() As Boolean = includeHeader
	Public ReadOnly Property IncludeFooter() As Boolean = includeFooter
	' Additional properties...
End Class

' Usage with IronPDF
Private pdfSettings = New PdfGenerationSettings("My PDF Title", True, False)
Private renderOptions = New ChromePdfRenderOptions With {
	.PaperSize = IronPdf.Rendering.PdfPaperSize.A4,
	.MarginTop = 20,
	.MarginBottom = 20,
	.MarginLeft = 10,
	.MarginRight = 10,
	.Title = pdfSettings.Title
}
' Apply settings from PdfGenerationSettings
If pdfSettings.IncludeHeader Then
	renderOptions.TextHeader = New TextHeaderFooter With {
		.CenterText = "Page {page} of {total-pages}",
		.DrawDividerLine = True
	}
End If
Dim pdfDocument = New IronPdf.ChromePdfRenderer()
pdfDocument.RenderingOptions = renderOptions
pdfDocument.RenderHtmlAsPdf("<html><body><h1>Hello, IronPDF!</h1></body></html>").SaveAs("CustomizedDocument.pdf")

Public Class PdfGenerationSettings(String title, Boolean includeHeader, Boolean includeFooter)
	Public ReadOnly Property Title() As String = title
	Public ReadOnly Property IncludeHeader() As Boolean = includeHeader
	Public ReadOnly Property IncludeFooter() As Boolean = includeFooter
	' Additional properties...
End Class

' Usage with IronPDF
Private pdfSettings = New PdfGenerationSettings("My PDF Title", True, False)
Private renderOptions = New ChromePdfRenderOptions With {
	.PaperSize = IronPdf.Rendering.PdfPaperSize.A4,
	.MarginTop = 20,
	.MarginBottom = 20,
	.MarginLeft = 10,
	.MarginRight = 10,
	.Title = pdfSettings.Title
}
' Apply settings from PdfGenerationSettings
If pdfSettings.IncludeHeader Then
	renderOptions.TextHeader = New TextHeaderFooter With {
		.CenterText = "Page {page} of {total-pages}",
		.DrawDividerLine = True
	}
End If
Dim pdfDocument = New IronPdf.ChromePdfRenderer()
pdfDocument.RenderingOptions = renderOptions
pdfDocument.RenderHtmlAsPdf("<html><body><h1>Hello, IronPDF!</h1></body></html>").SaveAs("CustomizedDocument.pdf")

En este ejemplo, la clase PdfGenerationSettings utiliza un Constructor Primario de C# para inicializar propiedades relacionadas con configuraciones de generación de PDF, las cuales se pueden usar posteriormente para determinar qué opciones de renderización agregar y cuáles omitir. La salida contiene un texto de encabezado y título tal como fue establecido usando el parámetro del constructor primario.

Constructor primario de C# (Cómo funciona para el desarrollador): Figura 3 - PDF de salida del ejemplo de código anterior

Conclusión

En conclusión, los Constructores Primarios en C# presentan un enfoque refinado y expresivo para la inicialización de clases. Su sintaxis declarativa mejora la legibilidad del código, promueve la inmutabilidad y simplifica el proceso de crear objetos con valores predeterminados. Ya sea que estés definiendo propiedades, haciendo cumplir la inmutabilidad o adoptando valores predeterminados, los Constructores Primarios empoderan a los desarrolladores para dominar el arte de la inicialización de clases en el mundo dinámico de la programación en C#.

Mientras que la integración directa de Constructores Primarios de C# con IronPDF podría no ser el enfoque principal, estos dos elementos pueden trabajar armoniosamente. Los Constructores Primarios de C# mejoran la claridad y simplicidad de la inicialización de clases, haciéndolos valiosos para definir estructuras o configuraciones relacionadas con los flujos de trabajo de IronPDF.

Aprovecha la potencia de IronPDF para una generación robusta de PDFs, y emplea Constructores Primarios de C# donde la elegancia en la inicialización de clases sea primordial. Este dúo dinámico te permite navegar las complejidades de la generación de documentos con creatividad y eficiencia en el vibrante mundo de la programación en C#.

IronPDF ofrece una prueba gratuita y su licencia lite comienza desde $999.

Jacob Mellor

Chatea con el equipo de ingeniería ahora

Director de Tecnología

Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.

...