O que são records em C#?

Question

Accepted Answer

**Records** (C# 9+) são uma forma concisa de definir tipos que são principalmente **transportadores de dados imutáveis** com **igualdade baseada em valor**. Eles geram automaticamente boilerplate (construtor, igualdade, `ToString`, etc.), tornando-os ideais para DTOs, valores de domínio e modelagem de dados.

## Definindo um record (sintaxe posicional)

```csharp
// one line generates: constructor, properties, equality, ToString, deconstruction
public record Person(string Name, int Age);

var p1 = new Person("Ann", 30);
p1.Name;                          // "Ann" (read-only property)
Console.WriteLine(p1);             // Person { Name = Ann, Age = 30 } — ToString generated
```

A sintaxe posicional `record Person(string Name, int Age)` gera tudo — propriedades, construtor, `ToString`, igualdade, desconstrução — eliminando o boilerplate que uma classe regular precisaria.

## Igualdade baseada em valor (a diferença fundamental em relação a classes)

```csharp
var a = new Person("Ann", 30);
var b = new Person("Ann", 30);
a == b;        // TRUE — records compare by VALUE (all properties equal)
// (a regular class would be FALSE here — classes compare by reference)
```

Ao contrário de classes (que comparam por identidade de referência), records comparam por **valor** — dois records com os mesmos valores de propriedade são iguais. Isso é exatamente o que você quer para objetos de dados.

## Imutabilidade e mutação não-destrutiva (with)

```csharp
public record Person(string Name, int Age);   // properties are init-only (immutable)

var p1 = new Person("Ann", 30);
var p2 = p1 with { Age = 31 };   // `with` creates a COPY with some properties changed
// p1 unchanged (immutable); p2 = Person { Name = Ann, Age = 31 }
```

Records são imutáveis por padrão, e a **expressão `with`** cria uma cópia modificada (mutação não-destrutiva) — ideal para trabalhar com dados imutáveis.

## record class vs record struct

```csharp
public record class Ref(int X);    // a reference type (default) with value equality
public record struct Val(int X);   // a VALUE type record (C# 10)
```

## Por que isso importa

Records são uma importante funcionalidade moderna de C# (C# 9+) que torna a definição de tipos de dados imutáveis concisa e correta, então compreendê-los é valioso para o desenvolvimento moderno de C#.

Seus benefícios principais abordam necessidades reais: eles **eliminam boilerplate** (gerando automaticamente construtores, propriedades, `ToString`, igualdade e desconstrução a partir de uma declaração de uma linha — versus o código substancial que uma classe regular requer), e fornecem **igualdade baseada em valor** (dois records com propriedades iguais são iguais, diferentemente de classes que comparam por referência) — que é exatamente o comportamento que você quer para objetos de dados, DTOs e valores de domínio, e que classes acertam errado por padrão.

Records também são **imutáveis por padrão** com a elegante **expressão `with`** para mutação não-destrutiva (criando cópias modificadas), apoiando o estilo imutável e funcional que é cada vez mais favorecido para código mais seguro e previsível.

Compreender records — a sintaxe concisa, igualdade de valor, imutabilidade com `with`, e record structs — é valioso para escrever C# moderno limpo, já que são a forma idiomática de modelar dados (DTOs, modelos de API, objetos de valor, estado imutável) e são amplamente utilizados em codebases atuais.

Saber quando usar um record (dados imutáveis com semântica de valor) versus uma classe (objetos mutáveis com identidade e comportamento rico) reflete fluência com C# moderno.

Já que records simplificam dramaticamente a modelagem de dados enquanto fornecem igualdade correta e imutabilidade — necessidades comuns que eram tediosas e propensas a erros antes — são uma funcionalidade importante e frequentemente usada que é um marco do código C# moderno e limpo.