C# Record Vs Class (Cómo Funciona Para Desarrolladores)

En el mundo de C#, se utilizan dos estructuras principales para modelar y encapsular datos: clases y Registros. Ambos sirven como tipos de referencia, pero difieren significativamente en su uso previsto, comportamiento y cómo manejan la igualdad. Esta guía diseccionará estas diferencias, proporcionando ejemplos claros y usos prácticos para ayudar a los desarrolladores a elegir la estructura adecuada a sus necesidades. También conoceremos la Biblioteca IronPDF.

Clases en C#: Lo básico

Las clases han sido la piedra angular de la programación orientada a objetos en C#, diseñadas para encapsular datos y comportamiento. Son tipos de referencia, lo que significa que dos instancias de clase con los mismos valores se consideran dos objetos distintos. Esta distinción es crucial cuando se comparan dos instancias de clase; la comparación por defecto se basa en referencias, no en valores.

public class Person
{
    public int Id { get; set; }
    public string FullName { get; set; }
}

public class Person
{
    public int Id { get; set; }
    public string FullName { get; set; }
}

Public Class Person
	Public Property Id() As Integer
	Public Property FullName() As String
End Class

En el ejemplo anterior, Persona es una clase con las propiedades Id y FullName. Aunque dos instancias de Persona tengan idénticos valores de Id y NombreCompleto, no se consideran iguales por defecto porque son dos referencias diferentes en memoria.

Registros en C#: Estructuras de datos inmutables

Introducido en C#, el tipo record es una adición más reciente destinada a simplificar la creación de estructuras de datos inmutables, proporcionando una alternativa robusta a las estructuras de clases tradicionales. A diferencia de las clases, los registros ofrecen una semántica de igualdad basada en valores, lo que los hace ideales para objetos de transferencia de datos o pequeñas estructuras de datos con poco o ningún comportamiento.

public record Person(int Id, string FullName);

public record Person(int Id, string FullName);

'INSTANT VB TODO TASK: C# 'records' are not converted by Instant VB:
'public record Person(int Id, string FullName)

En el ejemplo anterior, la definición del registro es más sucinta, lo que reduce el código repetitivo. Los registros admiten automáticamente la mutación no destructiva y la comparación basada en valores. Dos instancias de registro con los mismos valores se consideran iguales, en consonancia con la semántica de valores.

Usos prácticos: Cuándo usar Record vs. Class

La elección entre una clase y un registro, u otras estructuras de datos en C#, depende de la complejidad de los datos que esté modelando y de los comportamientos que requiera su aplicación. Las clases están diseñadas específicamente para estructuras de datos complejas, acomodando comportamientos (métodos) y permitiendo instancias mutables según sea necesario. Los registros, por su parte, son ejemplos perfectos de una estructura de datos sencilla, diseñada con características inmutables e igualdad basada en valores, ideal para datos que permanecen constantes tras su creación.

Las clases son ideales cuando su estructura de datos requiere encapsular datos y comportamientos o cuando necesita manipular los datos después de su creación. Esta flexibilidad convierte a las clases en la opción más adecuada para la programación orientada a objetos tradicional y para la creación de estructuras de datos complejas.

Los registros destacan en situaciones en las que la inmutabilidad de los datos es crucial o cuando se trata de estructuras de datos sencillas que sirven principalmente como contenedores de datos. Su igualdad incorporada basada en valores y su sintaxis concisa los hacen excelentes para objetos de transferencia de datos u objetos de valor.

Tipos de valor y tipos de referencia

Comprender la diferencia entre tipo de valor y tipo de referencia en C# es vital. Las clases son tipos de referencia, lo que significa que las variables contienen una referencia a los datos reales en memoria. Esta característica conduce a la comparación de igualdad basada en referencias por defecto.

Los registros, aunque también son tipos de referencia, emulan la semántica de los valores a través de su igualdad incorporada basada en valores, lo que hace que se comporten en cierto modo como tipos de valores en las comparaciones.

Ejemplos de código: Implementación de clases y registros

Implementemos una clase y un registro para resaltar las diferencias de sintaxis y comportamiento.

Implementación de la clase:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public Product(int id, string name)
    {
        Id = id;
        Name = name;
    }
}

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public Product(int id, string name)
    {
        Id = id;
        Name = name;
    }
}

Public Class Product
	Public Property Id() As Integer
	Public Property Name() As String
	Public Sub New(ByVal id As Integer, ByVal name As String)
		Me.Id = id
		Me.Name = name
	End Sub
End Class

Realización de registros:

public record Product(int Id, string Name);

public record Product(int Id, string Name);

'INSTANT VB TODO TASK: C# 'records' are not converted by Instant VB:
'public record Product(int Id, string Name)

Fíjate en la brevedad y sencillez de la implementación del registro. El registro genera automáticamente el constructor, las propiedades y los métodos para la igualdad basada en valores.

Entender la igualdad: Referencia frente a valor

La principal diferencia entre los tipos class y record en C# radica en cómo gestionan la igualdad. Las clases utilizan la igualdad de referencias, lo que significa que dos instancias son iguales si apuntan a la misma ubicación de memoria. Los registros utilizan la igualdad de valores, considerando dos instancias iguales si sus propiedades tienen los mismos valores.

Ejemplo de igualdad de referencia

var classInstance1 = new Person { Id = 1, Name = "Iron Software" };
var classInstance2 = new Person { Id = 1, Name = "Iron developer" };
Console.WriteLine(classInstance1 == classInstance2); //  Salidas: Falso

var classInstance1 = new Person { Id = 1, Name = "Iron Software" };
var classInstance2 = new Person { Id = 1, Name = "Iron developer" };
Console.WriteLine(classInstance1 == classInstance2); //  Salidas: Falso

Dim classInstance1 = New Person With {
	.Id = 1,
	.Name = "Iron Software"
}
Dim classInstance2 = New Person With {
	.Id = 1,
	.Name = "Iron developer"
}
Console.WriteLine(classInstance1 = classInstance2) '  Salidas: Falso

Ejemplo de igualdad de valores

var recordInstance1 = new Person(1, "Iron Software");
var recordInstance2 = new Person(1, "Iron Developer");
Console.WriteLine(recordInstance1 == recordInstance2); //  Salidas: True

var recordInstance1 = new Person(1, "Iron Software");
var recordInstance2 = new Person(1, "Iron Developer");
Console.WriteLine(recordInstance1 == recordInstance2); //  Salidas: True

Dim recordInstance1 = New Person(1, "Iron Software")
Dim recordInstance2 = New Person(1, "Iron Developer")
Console.WriteLine(recordInstance1 = recordInstance2) '  Salidas: True

Funciones avanzadas: Registros

Los registros incorporan varias funciones avanzadas que responden a la necesidad de estructuras de datos inmutables e igualdad basada en valores. La expresión with permite crear una nueva instancia de registro copiando un registro existente pero con algunas propiedades modificadas, lo que demuestra una mutación no destructiva.

Mutación no destructiva con registros:

var originalRecord = new Person(1, "Doe");
var modifiedRecord = originalRecord with { Name = "Iron Developer" };

var originalRecord = new Person(1, "Doe");
var modifiedRecord = originalRecord with { Name = "Iron Developer" };

Dim originalRecord = New Person(1, "Doe")
'INSTANT VB TODO TASK: C# 'with expressions' are not converted by Instant VB:
'var modifiedRecord = originalRecord with { Name = "Iron Developer" }

Esta característica es especialmente útil cuando se trabaja con estructuras de datos inmutables, ya que proporciona una forma de "modificar" una instancia sin alterar los datos originales.

Introducción a la biblioteca IronPDF

IronPDF es una biblioteca PDF para desarrolladores .NET que ofrece una solución completa para crear, editar y gestionar documentos PDF directamente en aplicaciones .NET. Simplifica el proceso de generación de PDF permitiendo a los desarrolladores Convertir HTML CSS, JavaScript e imágenes en PDF. IronPDF es compatible con diversos marcos de trabajo y tipos de proyectos .NET, incluidas aplicaciones web, de escritorio y de consola, en múltiples sistemas operativos como Windows, Linux y macOS.

Además de la creación de PDF, IronPDF ofrece funciones de edición de PDF, configuración de propiedades y seguridad, trabajo con formularios PDF y extracción de contenido. Está diseñado para satisfacer las necesidades de los desarrolladores que buscan una herramienta fiable para integrar la funcionalidad PDF en sus proyectos .NET.

Ejemplo de código

La creación de un PDF en C# utilizando IronPDF se puede lograr tanto con clases como con registros. A continuación, se muestran ejemplos de ambos enfoques para generar un documento PDF sencillo. La principal diferencia entre las clases y los registros en C# radica en su uso previsto: las clases son mutables por defecto y están diseñadas para la programación orientada a objetos tradicional, mientras que los registros son inmutables y están diseñados para la programación basada en valores, lo que los hace ideales para el modelado de datos.

Utilizar una clase

En este ejemplo, definiremos una clase PdfGenerator que contiene un método para crear un PDF a partir de una cadena HTML dada.

using IronPdf;
public class PdfGenerator
{
    public string HtmlContent { get; set; }
    public PdfGenerator(string htmlContent)
    {
        HtmlContent = htmlContent;
    }
    public void GeneratePdf(string filePath)
    {
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(HtmlContent);
        pdfDocument.SaveAs(filePath);
    }
}
class Program
{
    public static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        var generator = new PdfGenerator("<h1>Hello, World from Class!</h1>");
        generator.GeneratePdf("ClassExample.pdf");
    }
}

using IronPdf;
public class PdfGenerator
{
    public string HtmlContent { get; set; }
    public PdfGenerator(string htmlContent)
    {
        HtmlContent = htmlContent;
    }
    public void GeneratePdf(string filePath)
    {
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(HtmlContent);
        pdfDocument.SaveAs(filePath);
    }
}
class Program
{
    public static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        var generator = new PdfGenerator("<h1>Hello, World from Class!</h1>");
        generator.GeneratePdf("ClassExample.pdf");
    }
}

Imports IronPdf
Public Class PdfGenerator
	Public Property HtmlContent() As String
	Public Sub New(ByVal htmlContent As String)
		Me.HtmlContent = htmlContent
	End Sub
	Public Sub GeneratePdf(ByVal filePath As String)
		Dim renderer = New ChromePdfRenderer()
		Dim pdfDocument = renderer.RenderHtmlAsPdf(HtmlContent)
		pdfDocument.SaveAs(filePath)
	End Sub
End Class
Friend Class Program
	Public Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		Dim generator = New PdfGenerator("<h1>Hello, World from Class!</h1>")
		generator.GeneratePdf("ClassExample.pdf")
	End Sub
End Class

Salida

Utilizar un registro

En cambio, un registro en C# es inmutable después de la inicialización. A continuación se muestra cómo conseguir un resultado similar con un registro, utilizando expresiones with para las modificaciones, que básicamente devuelven una nueva instancia del registro con los cambios deseados.

using IronPdf;
public record PdfGeneratorRecord(string HtmlContent)
{
    public void GeneratePdf(string filePath)
    {
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(this.HtmlContent);
        pdfDocument.SaveAs(filePath);
    }
}
class Program
{
    public static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        var recordGenerator = new PdfGeneratorRecord("<h1>Hello, World from Record!</h1>");
        recordGenerator.GeneratePdf("RecordExample.pdf");
    }
}

using IronPdf;
public record PdfGeneratorRecord(string HtmlContent)
{
    public void GeneratePdf(string filePath)
    {
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(this.HtmlContent);
        pdfDocument.SaveAs(filePath);
    }
}
class Program
{
    public static void Main(string [] args)
    {
        License.LicenseKey = "License-Key";
        var recordGenerator = new PdfGeneratorRecord("<h1>Hello, World from Record!</h1>");
        recordGenerator.GeneratePdf("RecordExample.pdf");
    }
}

Imports IronPdf
'INSTANT VB TODO TASK: C# 'records' are not converted by Instant VB:
'public record PdfGeneratorRecord(string HtmlContent)
'{
'	public void GeneratePdf(string filePath)
'	{
'		var renderer = New ChromePdfRenderer();
'		var pdfDocument = renderer.RenderHtmlAsPdf(Me.HtmlContent);
'		pdfDocument.SaveAs(filePath);
'	}
'}
Friend Class Program
	Public Shared Sub Main(ByVal args() As String)
		License.LicenseKey = "License-Key"
		Dim recordGenerator = New PdfGeneratorRecord("<h1>Hello, World from Record!</h1>")
		recordGenerator.GeneratePdf("RecordExample.pdf")
	End Sub
End Class

Salida

Estos ejemplos ilustran cómo generar un archivo PDF utilizando IronPDF tanto con una clase como con un registro en C#. La elección entre utilizar una clase o un registro depende de sus necesidades específicas: si necesita objetos que van a ser modificados después de su creación, una clase podría ser más apropiada. Si se trata de datos que no deben cambiar una vez creados, o si aprecia la sencillez sintáctica y la seguridad de la inmutabilidad, un registro podría ser la mejor opción.

Conclusión

En conclusión, las clases ofrecen características tradicionales orientadas a objetos con estado mutable e igualdad basada en referencias, mientras que los registros proporcionan un enfoque moderno para definir estructuras de datos inmutables con igualdad basada en valores.

La elección entre utilizar una clase o un registro debe guiarse por los requisitos específicos de su aplicación, teniendo en cuenta factores como la necesidad de inmutabilidad, la complejidad de la estructura de datos y el método preferido de comparación de igualdades. IronPDF para quienes deseen integrar la funcionalidad PDF en sus aplicaciones .NET, con licencias a partir de 749 dólares.