Constructor primario en C# (Cómo funciona para desarrolladores)

En el panorama de la programación orientada a objetos de C#, la introducción de los Constructores primarios aporta un nuevo nivel de elegancia y simplicidad al lenguaje. Los constructores primarios, junto con funciones como los interceptores y las expresiones de colección, surgieron en C# 12 como una potente función que ofrecía una sintaxis más concisa para declarar constructores con parámetros. Puede explorar los constructores primarios en profundidad en la páginaGuía Microsoft C#.

En este artículo, aprenderemos a utilizar los Constructores Primarios de C# 12 de forma 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.

Entendiendo lo Básico: Constructores en C#

Los constructores desempeñan un papel fundamental en la programación orientada a objetos, ya que sirven para inicializar objetos. Tradicionalmente, los desarrolladores de C# han utilizado el constructor por defecto o constructores parametrizados para configurar el estado inicial de sus clases. Sin embargo, la introducción de Primary Constructors añade un enfoque más racionalizado 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 definición y asignación de valores a las propiedades, ofreciendo una sintaxis más declarativa y legible.

Ventajas de los constructores primarios

1. Concisión: Los constructores primarios proporcionan una sintaxis sucinta, reduciendo el código repetitivo y mejorando la legibilidad.

2. Ámbito: A diferencia de los constructores tradicionales, los parámetros de los constructores primarios están en el ámbito de toda la clase o estructura, ofreciendo flexibilidad en su uso.

3. Valores por defecto: Los valores por defecto de los parámetros simplifican la creación de objetos, haciéndola más cómoda para los desarrolladores.

Declaración de un constructor primario

La sintaxis de un Constructor Primario implica declarar las propiedades directamente en la cabecera de la clase. Consideremos un ejemplo básico de clase Persona:

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 Integer Age {get;} = age public override String ToString()
	If True Then
		Return $"Name: {Name}, Age: {Age}"
	End If
End Class

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

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

En este ejemplo, el constructor primario de la estructura Point inicializa las propiedades X y Y, mostrando lo concisa y expresiva que puede ser la sintaxis.

Ejemplo 2: Registrador configurable con ajustes por defecto

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

Aquí, el constructor primario de la clase Logger proporciona valores por defecto para filePath y level, haciéndolo flexible y fácil de usar a la vez que mantiene la configurabilidad.

Ejemplo 3: Inyección de dependencia

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

Los constructores primarios se adaptan a los escenarios de inyección de dependencias. En este ejemplo, una clase de controlador indica sus dependencias, mejorando la mantenibilidad y facilitando las pruebas unitarias.

Ejemplo 4: Creació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

En este ejemplo, el constructor primario de la clase Shape constituye la base de una jerarquía de formas geométricas. Las subclases como Rectángulo y Círculo aprovechan el constructor primario para una inicialización consistente. La propia clase Rectangle declara el constructor primario y pasa los parámetros capturados del constructor primario a los parámetros primarios de la clase Shape. La clase Circle muestra flexibilidad definiendo su constructor dentro de toda la clase y luego pasando sus parámetros como valores por defecto para el constructor Shape utilizando la palabra clave base.

Presentación de IronPDF

IronPDF es una versátil biblioteca de C# que permite a los desarrolladores crear, manipular y convertir archivos PDF sin esfuerzo. Ya sea que esté generando facturas, informes o cualquier otro documento, IronPDF le permite convertir sin problemas contenido HTML en PDF pulidos y profesionales directamente dentro de su aplicación C#.

Instalación de IronPDF: Inicio rápido

Para incorporar IronPDF a su proyecto C#, comience por instalar el paquete IronPDF NuGet. Ejecute el siguiente comando en la consola del gestor de paquetes:

Install-Package IronPdf

Como alternativa, localice "IronPDF" en el gestor de paquetes NuGet y proceda a la instalación desde allí.

Generación de PDF con IronPDF

Crear un PDF con IronPDF es un proceso ágil. Considere 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")

En este ejemplo, IronPDF se utiliza para convertir el contenido HTML en un documento PDF, que posteriormente se guarda en la ubicación especificada. Para más detalles sobre la creación y manipulación de PDF en C#, visite este completoenlace al tutorial, y para explorar más por favor visite estedocumentación página.

C# Constructores primarios: La revolución de 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 clase. Exploremos si esta elegante función puede integrarse perfectamente con IronPDF.

Integración de C# Constructores primarios con IronPDF

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

Sin embargo, los desarrolladores pueden aprovechar los Primary Constructors de C# al definir clases o estructuras personalizadas relacionadas con configuraciones o modelos de datos de IronPDF. Por ejemplo, si su aplicación requiere una estructura de clases específica para gestionar ajustes o configuraciones relacionados con PDF, los constructores primarios de C# pueden ser una herramienta valiosa para inicializar estas clases de forma concisa.

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();
// Apply settings from PdfGenerationSettings
renderOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderOptions.MarginTop = 20;
renderOptions.MarginBottom = 20;
renderOptions.MarginLeft = 10;
renderOptions.MarginRight = 10;
renderOptions.Title = pdfSettings.Title ?? string.Empty;
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();
// Apply settings from PdfGenerationSettings
renderOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderOptions.MarginTop = 20;
renderOptions.MarginBottom = 20;
renderOptions.MarginLeft = 10;
renderOptions.MarginRight = 10;
renderOptions.Title = pdfSettings.Title ?? string.Empty;
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()
' Apply settings from PdfGenerationSettings
renderOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderOptions.MarginTop = 20
renderOptions.MarginBottom = 20
renderOptions.MarginLeft = 10
renderOptions.MarginRight = 10
renderOptions.Title = If(pdfSettings.Title, String.Empty)
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 las propiedades relacionadas con la configuración de generación de PDF. Más tarde se puede utilizar para averiguar qué opciones de renderizado añadir y cuáles omitir. La salida contiene un texto de cabecera y el título tal y como se estableció utilizando el parámetro principal del constructor.

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, fomenta la inmutabilidad y simplifica el proceso de creación de objetos con valores por defecto. Ya se trate de definir propiedades, aplicar la inmutabilidad o adoptar valores predeterminados, los Constructores primarios permiten a los desarrolladores dominar el arte de la inicialización de clases en el dinámico mundo de la programación en C#.

Aunque la integración directa de los Constructores Primarios de C# con IronPDF puede no ser el objetivo principal, estos dos elementos pueden trabajar juntos 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.

Aproveche la potencia de IronPDF para una sólida generación de PDF y emplee Primary Constructors de C# cuando la elegancia en la inicialización de clases sea primordial. Este dúo dinámico le capacita para navegar por las complejidades de la generación de documentos con creatividad y eficacia en el vibrante mundo de la programación en C#.

IronPDF ofrece un**Prueba gratuita y su litelicencia comienza a partir de $749.