Pruebas en un entorno real
Pruebe en producción sin marcas de agua.
Funciona donde lo necesites.
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ágina Guí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.
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#.
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.
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.
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.
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.
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.
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.
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#.
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í.
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 completo enlace al tutorial, y para explorar más por favor visite este documentación página.
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.
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.
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 lite licencia comienza a partir de $749.
9 productos API .NET para sus documentos de oficina