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

Clases en C#: Lo básico

Las clases han sido un pilar 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 una clase con los mismos valores se consideran dos objetos separados. Esta distinción es crucial al comparar dos instancias de clase; la comparación por defecto se basa en la referencia, no en el valor.

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; }
}

En el ejemplo anterior, Person es una clase con propiedades Id y FullName. Incluso si dos instancias de Person tienen valores idénticos de Id y FullName, por defecto no se consideran iguales porque son dos referencias diferentes en memoria.

Records en C#: Estructuras de datos inmutables

Introducido en C#, el tipo de registro es una nueva adición destinada a simplificar la creación de estructuras de datos inmutables, proporcionando una alternativa robusta a las estructuras de clase tradicionales. A diferencia de las clases, los registros ofrecen semánticas de igualdad basadas en el valor, 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);

En el ejemplo anterior, la definición de registro es más concisa, reduciendo 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, alineándose con las semánticas de valor.

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

Elegir entre una clase y un registro, u otras estructuras de datos en C#, depende de la complejidad de los datos que estás modelando y los comportamientos requeridos por tu 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 otro lado, son ejemplos perfectos de una estructura de datos simple, diseñados con características inmutables y igualdad basada en el valor, ideales para datos que permanecen constantes después de la creación.

Las clases son ideales cuando tu estructura de datos requiere encapsular datos y comportamientos o cuando necesitas manipular los datos después de su creación. Esta flexibilidad hace que las clases sean una referencia para la mayoría de escenarios tradicionales de programación orientada a objetos y cuando se crean estructuras de datos complejas.

Los registros brillan en escenarios donde la inmutabilidad de los datos es crucial o cuando estás lidiando con estructuras de datos simples que principalmente sirven como contenedores de datos. Su igualdad basada en valores incorporada y su sintaxis concisa los hacen excelentes para objetos de transferencia de datos u objetos de valor.

Tipos de valor y tipos de referencia

Entender 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 tienen una referencia a los datos reales en la memoria. Esta característica conduce a la comparación de igualdad por referencia de forma predeterminada.

Los registros, aunque también son tipos de referencia, emulan semánticas de valor a través de su igualdad basada en valores incorporada, haciéndolos comportarse algo así como tipos de valor en las comparaciones.

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

Vamos a implementar una clase y un registro para resaltar las diferencias en sintaxis y comportamiento.

Implementación de 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;
    }
}

Implementación de Registro:

public record Product(int Id, string Name);

public record Product(int Id, string Name);

Observe la brevedad y simplicidad 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.

Entendiendo la igualdad: Referencia vs. Valor

La diferencia central entre tipos de clase y registro en C# radica en cómo manejan la igualdad:

1. Las clases usan igualdad de referencia por defecto, lo que significa que dos instancias son iguales si apuntan a la misma ubicación de memoria.

2. Los registros usan igualdad de valor por defecto, considerando dos instancias iguales si sus propiedades tienen los mismos valores.

Ejemplo de Igualdad de Referencia (Clase)

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

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

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

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

Dos instancias de una clase con los mismos valores de propiedad no se consideran iguales porque son objetos diferentes en memoria.

Ejemplo de Igualdad de Valor

public record Person(int Id, string Name);

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

public record Person(int Id, string Name);

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

Dos instancias de un registro con los mismos valores de propiedad se consideran iguales por defecto.

Características avanzadas: Registros

Los registros vienen con varias características avanzadas que satisfacen la necesidad de estructuras de datos inmutables y igualdad basada en valores. La expresión with permite crear una nueva instancia de registro copiando un registro existente pero con algunas propiedades modificadas, demostrando la 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" };

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

Introducción a la biblioteca IronPDF

IronPDF es una biblioteca PDF para desarrolladores de .NET, ofreciendo una solución integral para crear, editar y gestionar documentos PDF directamente dentro de aplicaciones .NET. Simplifica el proceso de generación de PDF permitiendo a los desarrolladores convertir HTML en PDFs, CSS, JavaScript e imágenes en PDFs. IronPDF soporta una variedad de marcos y tipos de proyectos .NET, incluidas aplicaciones web, de escritorio y de consola, en múltiples sistemas operativos como Windows, Linux y macOS.

Más allá de la creación de PDFs, IronPDF proporciona capacidades para editar PDFs, configurar propiedades y seguridad, trabajar con formularios PDF y extraer contenido. Está diseñado para satisfacer las necesidades de los desarrolladores que buscan una herramienta confiable para integrar la funcionalidad PDF en sus proyectos .NET.

using IronPdf;
using System;

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"; // Set your license key here

        var generator = new PdfGenerator("<h1>Hello, World from Class!</h1>");
        generator.GeneratePdf("ClassExample.pdf");
    }
}

using IronPdf;
using System;

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"; // Set your license key here

        var generator = new PdfGenerator("<h1>Hello, World from Class!</h1>");
        generator.GeneratePdf("ClassExample.pdf");
    }
}

using IronPdf;
using System;

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"; // Set your license key here

        var recordGenerator = new PdfGeneratorRecord("<h1>Hello, World from Record!</h1>");
        recordGenerator.GeneratePdf("RecordExample.pdf");
    }
}

using IronPdf;
using System;

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"; // Set your license key here

        var recordGenerator = new PdfGeneratorRecord("<h1>Hello, World from Record!</h1>");
        recordGenerator.GeneratePdf("RecordExample.pdf");
    }
}

Conclusión

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

La elección entre usar una clase o un registro debe estar guiada por los requisitos específicos de tu aplicación, considerando factores como la necesidad de inmutabilidad, la complejidad de la estructura de datos y el método preferido de comparación de igualdad. Descubre la Prueba Gratuita de IronPDF para aquellos que buscan integrar funcionalidad PDF en sus aplicaciones .NET, con licencias desde $799.