C# Academy · Lezione

Pattern per oggetti immutabili

Progetti oggetti che non cambiano dopo la creazione.

Pattern per oggetti immutabili è una lezione C# Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C# Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C# Academy include 4 lezioni in totale.

Progettare oggetti immutabili

Un oggetto immutabile non cambia mai dopo la costruzione. L'immutabilità elimina intere categorie di bug legati allo stato mutabile condiviso e rende gli oggetti sicuri da passare e memorizzare nella cache.

Proprietà con solo get

La proprietà immutabile più semplice ha il solo accessor get e viene assegnata una volta dal costruttore.

using System;

class Point {
    public int X { get; }
    public int Y { get; }
    public Point(int x, int y) { X = x; Y = y; }
}

var p = new Point(3, 4);
Console.WriteLine(p.X + "," + p.Y); // 3,4

init per la sintassi degli inizializzatori

Usi le proprietà init quando desidera l'immutabilità insieme alla comoda sintassi degli inizializzatori di oggetto.

using System;

class Color {
    public int R { get; init; }
    public int G { get; init; }
    public int B { get; init; }
}

var c = new Color { R = 255, G = 128, B = 0 };
Console.WriteLine(c.R + "," + c.G + "," + c.B); // 255,128,0

required per i campi obbligatori

Combini required + init affinché i campi essenziali non possano essere dimenticati né modificati.

using System;

class Money {
    public required decimal Amount { get; init; }
    public required string Currency { get; init; }
}

var m = new Money { Amount = 9.99m, Currency = "USD" };
Console.WriteLine(m.Amount + " " + m.Currency); // 9.99 USD

Restituire nuovi oggetti invece di modificarli

I tipi immutabili espongono le operazioni di "modifica" come metodi che restituiscono una nuova istanza, lasciando invariata quella originale.

using System;

class Point {
    public int X { get; init; }
    public int Y { get; init; }
    public Point Move(int dx, int dy) => new Point { X = X + dx, Y = Y + dy };
}

var a = new Point { X = 1, Y = 1 };
var b = a.Move(2, 3);
Console.WriteLine(a.X + "," + a.Y + " -> " + b.X + "," + b.Y); // 1,1 -> 3,4

Raccolte immutabili

Per i campi che contengono raccolte, memorizzi una raccolta immutabile o di sola lettura, in modo che il contenuto non possa essere modificato tramite l'oggetto.

using System;
using System.Collections.Immutable;

class Team {
    public ImmutableList<string> Members { get; init; } = ImmutableList<string>.Empty;
}

var t = new Team { Members = ["Ada", "Lin"] };
var t2 = new Team { Members = t.Members.Add("Sam") };
Console.WriteLine(t.Members.Count + " " + t2.Members.Count); // 2 3

Copia difensiva

Se deve accettare una raccolta modificabile, ne crei una copia all'ingresso, così le modifiche esterne non potranno propagarsi all'interno.

using System;
using System.Collections.Generic;
using System.Linq;

class Snapshot {
    private readonly int[] data;
    public Snapshot(IEnumerable<int> source) => data = source.ToArray();
    public IReadOnlyList<int> Data => data;
}

var list = new List<int> { 1, 2, 3 };
var snap = new Snapshot(list);
list.Add(4); // does not affect snap
Console.WriteLine(snap.Data.Count); // 3

Uguaglianza per valore

Gli oggetti immutabili spesso richiedono un'uguaglianza basata sul valore: due istanze con gli stessi dati vengono considerate uguali. I record la forniscono automaticamente; per le classi sono necessarie override.

using System;

record Coord(int X, int Y);

Console.WriteLine(new Coord(1, 2) == new Coord(1, 2)); // True

Thread safety senza sforzo

Poiché gli oggetti immutabili non cambiano mai, sono intrinsecamente thread-safe e possono essere condivisi senza lock.

using System;

class ReadonlyConfig {
    public required string Env { get; init; }
}

var cfg = new ReadonlyConfig { Env = "prod" };
// safe to read from many threads without synchronization
Console.WriteLine(cfg.Env); // prod

Campi readonly e struct

Usi i campi readonly e readonly struct per imporre l'immutabilità dei tipi valore a livello di campo.

using System;

readonly struct Vector {
    public readonly double X, Y;
    public Vector(double x, double y) { X = x; Y = y; }
    public double Length => Math.Sqrt(X * X + Y * Y);
}

Console.WriteLine(new Vector(3, 4).Length); // 5

Combinare il tutto

Un tipo completamente immutabile che combina required, init, uguaglianza per valore e un metodo di aggiornamento che non modifica l'istanza.

using System;

record Account(string Id, decimal Balance) {
    public Account Deposit(decimal amount) => this with { Balance = Balance + amount };
}

var a = new Account("A1", 100m);
var b = a.Deposit(50m);
Console.WriteLine(a.Balance + " -> " + b.Balance); // 100 -> 150

Verifica rapida

Verifichi il principio degli aggiornamenti immutabili.

Riepilogo

Ha imparato alcuni pattern per gli oggetti immutabili.

Usi proprietà con il solo accessor get o init e required per i dati obbligatori.
Modelli le modifiche come metodi che restituiscono nuove istanze.
Memorizzi raccolte immutabili o create tramite copia difensiva.
I record forniscono l'uguaglianza per valore e le copie con with; l'immutabilità garantisce la thread safety.

Domande Frequenti

La lezione «Pattern per oggetti immutabili» è gratuita?

Sì — il testo completo di «Pattern per oggetti immutabili» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C# Academy, passa a CoddyKit PRO. Il corso C# Academy include 4 lezioni in totale.

Cosa imparerò in «Pattern per oggetti immutabili»?

Progetti oggetti che non cambiano dopo la creazione. Eserciti C# Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C# Academy?

Non è richiesta alcuna esperienza precedente. C# Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Pattern per oggetti immutabili»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C# Academy?

Sì. Ogni lezione C# Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C# Academy