Registros vs. Classes em C# (Como funciona para desenvolvedores)

Classes em C#: O Básico

As classes têm sido um pilar da programação orientada a objetos em C#, projetadas para encapsular dados e comportamento. São tipos de referência, o que significa que duas instâncias de uma classe com os mesmos valores são consideradas dois objetos separados. Essa distinção é crucial ao comparar duas instâncias de classe; A comparação padrão é baseada em referência, não em 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; }
}

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

No exemplo acima, Pessoa é uma classe com propriedades Id e FullName . Mesmo que duas instâncias de Pessoa tenham valores idênticos de Id e FullName , elas não são consideradas iguais por padrão, pois são duas referências diferentes na memória.

Registros em C#: Estruturas de Dados Imutáveis

Introduzido em C#, o tipo de registro é uma adição mais recente que visa simplificar a criação de estruturas de dados imutáveis, fornecendo uma alternativa robusta às estruturas de classe tradicionais. Diferentemente das classes, os registros oferecem semântica de igualdade baseada em valores, tornando-os ideais para objetos de transferência de dados ou pequenas estruturas de dados com pouco ou nenhum comportamento.

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)

No exemplo acima, a definição do registro é mais sucinta, reduzindo o código repetitivo. Os registros suportam automaticamente mutações não destrutivas e comparações baseadas em valores. Duas instâncias de registro com os mesmos valores são consideradas iguais, em consonância com a semântica de valores.

Usos práticos: Quando usar record versus classe

A escolha entre uma classe e um registro, ou outras estruturas de dados em C#, depende da complexidade dos dados que você está modelando e dos comportamentos exigidos pela sua aplicação. As classes são projetadas especificamente para estruturas de dados complexas, acomodando comportamentos (métodos) e permitindo instâncias mutáveis ​​conforme necessário. Os registros, por outro lado, são exemplos perfeitos de uma estrutura de dados simples, projetada com características imutáveis ​​e igualdade baseada em valores, ideal para dados que permanecem constantes após a criação.

As classes são ideais quando sua estrutura de dados exige o encapsulamento de dados e comportamentos ou quando você precisa manipular os dados após sua criação. Essa flexibilidade faz das classes uma opção preferencial para a maioria dos cenários tradicionais de programação orientada a objetos e para a criação de estruturas de dados complexas.

Os registros se destacam em cenários onde a imutabilidade dos dados é crucial ou quando se lida com estruturas de dados simples que servem principalmente como contêineres de dados. A igualdade baseada em valores que elas proporcionam e a sintaxe concisa as tornam excelentes para objetos de transferência de dados ou objetos de valor.

Tipos de valor e tipos de referência

Entender a diferença entre tipo de valor e tipo de referência em C# é fundamental. Classes são tipos de referência, o que significa que variáveis ​​armazenam uma referência aos dados reais na memória. Essa característica leva à comparação de igualdade baseada em referência por padrão.

Os registros, embora também sejam tipos de referência, emulam a semântica de valor por meio de sua igualdade baseada em valor integrada, fazendo com que se comportem de maneira semelhante aos tipos de valor em comparações.

Exemplos de código: Implementando classes e registros

Vamos implementar uma classe e um registro para destacar as diferenças de sintaxe e comportamento.

Implementação da classe:

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

Implementação 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)

Observe a brevidade e a simplicidade da implementação do registro. O registro gera automaticamente o construtor, as propriedades e os métodos para igualdade baseada em valores.

Entendendo a Igualdade: Referência vs. Valor

A principal diferença entre classes e registros em C# reside, de fato, em como eles lidam com a igualdade:

1. Por padrão, as classes usam igualdade de referência, o que significa que duas instâncias são iguais se apontarem para o mesmo local de memória.

2. Por padrão, os registros utilizam a igualdade de valores, considerando duas instâncias iguais se suas propriedades tiverem os mesmos valores.

Exemplo de Igualdade de Referência (Classe)

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

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

Private classInstance1 = New Person With {
	.Id = 1,
	.Name = "Iron Software"
}
Private classInstance2 = New Person With {
	.Id = 1,
	.Name = "Iron Software"
}
Console.WriteLine(classInstance1 = classInstance2) ' Outputs: False

Duas instâncias de uma classe com os mesmos valores de propriedade não são consideradas iguais porque são objetos diferentes na memória.

Exemplo de igualdade de valores

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

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

Private recordInstance1 = New Person(1, "Iron Software")
Private recordInstance2 = New Person(1, "Iron Software")
Console.WriteLine(recordInstance1 = recordInstance2) ' Outputs: True

Por padrão, duas instâncias de um registro com os mesmos valores de propriedade são consideradas iguais.

Recursos avançados: Registros

Os registros vêm com diversos recursos avançados que atendem à necessidade de estruturas de dados imutáveis ​​e igualdade baseada em valores. A expressão with permite criar uma nova instância de registro copiando um registro existente, mas com algumas propriedades modificadas, demonstrando uma mutação não destrutiva.

Mutação não destrutiva com 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" }

Essa funcionalidade é útil ao trabalhar com estruturas de dados imutáveis, pois oferece uma maneira de "modificar" uma instância sem alterar os dados originais.

Introdução à Biblioteca IronPDF

IronPDF é uma biblioteca PDF para desenvolvedores .NET , que oferece uma solução completa para criar, editar e gerenciar documentos PDF diretamente em aplicativos .NET . Simplifica o processo de geração de PDFs, permitindo que os desenvolvedores convertam HTML em PDFs , CSS, JavaScript e imagens em PDFs. O IronPDF oferece suporte a uma variedade de frameworks .NET e tipos de projeto, incluindo aplicativos web, desktop e console, em diversos sistemas operacionais, como Windows, Linux e macOS.

Além da criação de PDFs, o IronPDF oferece recursos para editar PDFs, definir propriedades e segurança, trabalhar com formulários em PDF e extrair conteúdo. Ele foi projetado para atender às necessidades de desenvolvedores que buscam uma ferramenta confiável para integrar a funcionalidade de PDF em seus projetos .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");
    }
}

Imports IronPdf
Imports System

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

		Dim generator = New PdfGenerator("<h1>Hello, World from Class!</h1>")
		generator.GeneratePdf("ClassExample.pdf")
	End Sub
End Class

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

Imports IronPdf
Imports System

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

		Dim recordGenerator = New PdfGeneratorRecord("<h1>Hello, World from Record!</h1>")
		recordGenerator.GeneratePdf("RecordExample.pdf")
	End Sub
End Class

Conclusão

Em conclusão, as classes oferecem recursos tradicionais de orientação a objetos, como estado mutável e igualdade baseada em referência, enquanto os registros fornecem uma abordagem moderna para definir estruturas de dados imutáveis ​​com igualdade baseada em valor.

A escolha entre usar uma classe ou um registro deve ser guiada pelos requisitos específicos da sua aplicação, considerando fatores como a necessidade de imutabilidade, a complexidade da estrutura de dados e o método preferido de comparação de igualdade. Descubra a versão de avaliação gratuita do IronPDF para quem deseja integrar a funcionalidade de PDF em seus aplicativos .NET , com licenças a partir de $799.