Cosa sono i record in C#?

Question

Accepted Answer

I **record** (C# 9+) sono un modo conciso per definire tipi che sono principalmente **vettori di dati immutabili** con **uguaglianza basata sul valore**. Auto-generano boilerplate (costruttore, uguaglianza, `ToString`, ecc.), rendendoli ideali per DTO, valori di dominio e modellazione dati.

## Definire un record (sintassi posizionale)

```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
```

La sintassi posizionale `record Person(string Name, int Age)` genera tutto — proprietà, costruttore, `ToString`, uguaglianza, decostruzione — eliminando il boilerplate che una classe ordinaria richiederebbe.

## Uguaglianza basata sul valore (la differenza chiave rispetto alle classi)

```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)
```

A differenza delle classi (che confrontano per identità di riferimento), i record confrontano per **valore** — due record con gli stessi valori di proprietà sono uguali. Questo è esattamente quello che desideri per gli oggetti dati.

## Immutabilità e mutazione non distruttiva (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 }
```

I record sono immutabili per impostazione predefinita, e l'**espressione `with`** crea una copia modificata (mutazione non distruttiva) — ideale per lavorare con dati immutabili.

## 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)
```

## Perché è importante

I record sono una importante funzionalità moderna di C# (C# 9+) che rende la definizione di tipi dati immutabili concisa e corretta, quindi comprenderli è prezioso per lo sviluppo C# moderno.

I loro vantaggi chiave affrontano esigenze reali: **eliminano il boilerplate** (auto-generando costruttori, proprietà, `ToString`, uguaglianza e decostruzione da una dichiarazione di una riga — rispetto al codice sostanziale che una classe ordinaria richiede), e forniscono **uguaglianza basata sul valore** (due record con proprietà uguali sono uguali, a differenza delle classi che confrontano per riferimento) — che è esattamente il comportamento che desideri per gli oggetti dati, i DTO e i valori di dominio, e che le classi sbagliano per impostazione predefinita.

I record sono anche **immutabili per impostazione predefinita** con l'elegante **espressione `with`** per la mutazione non distruttiva (creazione di copie modificate), supportando lo stile immutabile e funzionale che è sempre più favorito per codice più sicuro e prevedibile.

Comprendere i record — la sintassi concisa, l'uguaglianza per valore, l'immutabilità con `with`, e i record struct — è prezioso per scrivere C# moderno e pulito, poiché sono il modo idiomatico di modellare dati (DTO, modelli API, value object, stato immutabile) e sono ampiamente utilizzati nei codebase attuali.

Sapere quando utilizzare un record (dati immutabili con semantica per valore) rispetto a una classe (oggetti mutabili con identità e comportamento ricco) riflette la padronanza del C# moderno.

Poiché i record semplificano drammaticamente la modellazione dati fornendo al contempo uguaglianza corretta e immutabilità — esigenze comuni che erano noiose e soggette a errori prima — sono una funzionalità importante e frequentemente utilizzata che è un marchio del codice C# moderno e pulito.