CodeGym /Corsi /C# SELF /Chiusura dei flussi e rilascio delle risorse ( using)

Chiusura dei flussi e rilascio delle risorse ( using)

C# SELF
Livello 36, Lezione 0
Disponibile

1. Come liberare correttamente le risorse in C#?

Immagina il sistema operativo come un bibliotecario severo. Hai preso un libro (aperto un file/stream), lo stai leggendo e poi... ti sei dimenticato di restituirlo! Il bibliotecario si arrabbia: "Come sarebbe a dire — il libro è ancora con te?!" Ecco, lo stesso succede con gli stream. Uno stream aperto occupa risorse: un file descriptor, un po' di memoria, e in più blocca il file per altre applicazioni.

Se non chiudi lo stream, il risultato può andare da "qualcosa non funziona" a "è tutto rotto, nessuno può scrivere su questo file". E se nel programma ci sono tanti stream non chiusi — il sistema può iniziare a "perdere" risorse e semplicemente smettere di funzionare.

Qual è il rischio?

  • Il file non viene chiuso, i comandi non arrivano al disco (ad esempio, in scrittura — i dati possono restare nel buffer).
  • Il file viene bloccato per altri processi — i colleghi e altri programmi si arrabbiano.
  • Limite dei file descriptor: su Windows/Linux i processi hanno limiti sul numero di file/stream aperti.

Interfaccia IDisposable

Qualsiasi classe che lavora con risorse non gestite (stream, file, database, socket), deve implementare l'interfaccia IDisposable.


public interface IDisposable
{
    void Dispose();
}

Dentro il metodo Dispose() di solito avviene il rilascio di tutte le povere risorse: finalmente il file viene chiuso, le connessioni si interrompono, la memoria viene liberata.

Gli stream sono oggetti che tengono in mano risorse importanti: file, connessioni, memoria. Se non li chiudi, il file può restare bloccato (il tuo Word ti dirà "file aperto da un'altra applicazione!"), e il sistema — senza memoria. Quindi è davvero importante liberare lo stream dopo aver finito di usarlo.

In .NET gli stream implementano l'interfaccia IDisposable. Questo significa: vanno chiusi chiamando Dispose() (o semplicemente mettendoli in un blocco using).

2. Modi per chiudere uno stream: dal pericoloso all'affidabile

Opzione 1. Chiusura "manuale": non farlo!

Questo è il modo vecchio. E anche se l'ho mostrato negli esempi precedenti, nello sviluppo moderno quasi nessuno lo usa più :P


var stream = new FileStream("file.txt", FileMode.Open);
// Lavoriamo con lo stream
stream.Close(); // oppure stream.Dispose()

Problema: se tra l'apertura e la chiusura succede un errore/eccezione, il file resta aperto e bloccato. È come se fossi scappato dalla biblioteca con il libro in mano, sentendo odore di pizza...

Opzione 2. Usiamo try...finally


FileStream stream = null;
try
{
    stream = new FileStream("file.txt", FileMode.Open);
    // Lavoriamo con lo stream
}
finally
{
    if (stream != null)
        stream.Dispose();
}

Questa opzione è affidabile: finally viene eseguito sempre, anche in caso di errore. Ma, diciamolo, è una rottura scrivere così.

Opzione 3. Bello e sicuro: operatore using

Sintassi classica (using ( ... ) { ... })


using (var stream = new FileStream("file.txt", FileMode.Open))
{
    // Lavoriamo con lo stream
}
// Qui stream.Dispose() viene chiamato automaticamente!

La cosa fondamentale — tutto quello che sta dentro il blocco using lavora con lo stream, e quando il blocco finisce — il file viene chiuso anche se qualcosa va storto (ad esempio, viene lanciata un'eccezione).

Opzione 4. Sintassi moderna

Sintassi moderna (using var)


using var stream = new FileStream("file.txt", FileMode.Open);
// Lavoriamo con lo stream
// ... Dispose viene chiamato automaticamente quando la variabile esce dallo scope

Fantastico! Non servono più parentesi graffe e livelli di indentazione inutili.

Come funziona "sotto il cofano"?

L'operatore using viene trasformato dal compilatore proprio in quel try...finally, ma lo fa lui per te. Battuta: "using scrive codice pulito al posto tuo — magari presto inizierà anche a bere caffè e a perdersi su Stack Overflow?".

Differenza tra using classico e moderno

Blocco using classico using var (dichiarazione)
Forma
using (var x = ...) { ... }
using var x = ...; ...
Scope Dentro le parentesi graffe del blocco Fino alla fine del blocco corrente (metodo, ciclo, ecc.)
Brevezza Un po' più prolisso Conciso, meno indentazione
Da quando C# 1.0 C# 8.0 e superiori

3. Cosa sono le dichiarazioni using?

5 anni fa il mondo ha visto un nuovo modo conciso di lavorare con oggetti IDisposable.

using-dichiarazione — è quando invece di un blocco dichiari una variabile con la parola chiave using, e questa verrà liberata automaticamente alla fine del blocco corrente (ad esempio, metodo o ciclo), e non alla fine delle parentesi graffe di un blocco aggiuntivo.


using var stream = new FileStream("file.txt", FileMode.Open);
// Lavoriamo con lo stream
Console.WriteLine(stream.Length);

// Qui il file è ancora aperto!

// ... fine del metodo
// stream.Dispose() viene chiamato qui automaticamente

Differenze chiave rispetto al using classico:

  • Non servono parentesi graffe, non si crea un blocco di codice annidato.
  • La variabile è disponibile fino alla fine di tutto il blocco in cui è dichiarata (di solito — metodo, a volte — ciclo, classe, se dichiarata a livello di classe).
  • Il rilascio della risorsa avviene solo quando il blocco di esecuzione termina.

Perché è una figata?

  • Meno livelli di annidamento — il codice è molto più corto e leggibile.
  • Più facile lavorare con più risorse — dichiara più variabili using di fila, e tutto verrà liberato quando finisce il metodo.
  • Meno possibilità di sbagliare — non ti dimentichi la zona dove dovevi chiamare Dispose().

4. Confronto: using classico vs. moderno

Dai, guardiamo il confronto in codice.

Modo classico


using (var reader = new StreamReader("input.txt"))
{
    using (var writer = new StreamWriter("output.txt"))
    {
        string line;
        while ((line = reader.ReadLine()) != null)
        {
            writer.WriteLine(line.ToUpper());
        }
    }
} // Qui entrambi i file verranno chiusi

Modo moderno (C# 8+)


using var reader = new StreamReader("input.txt");
using var writer = new StreamWriter("output.txt");

string line;
while ((line = reader.ReadLine()) != null)
{
    writer.WriteLine(line.ToUpper());
}
// Entrambi i file verranno chiusi qui, all'uscita dal metodo

Sembra più semplice, vero? Soprattutto se hai ancora più livelli di annidamento — il modo moderno ti salva la vita.

5. Quando e dove viene chiamato Dispose()?

Qui spesso gli studenti sbagliano: pensano che Dispose venga chiamato subito dopo la riga di utilizzo — ma non è così!

Guarda questo esempio:


void MyMethod()
{
    using var fileStream = new FileStream("data.bin", FileMode.Open);
    // ... tanto codice, magari anche cicli e chiamate annidate
    // fileStream è ancora aperto!

    // Qui puoi ancora accedere a fileStream
}
// Qui, sulla } del metodo, viene chiamato fileStream.Dispose()

Punto importante: Se dichiari una variabile using dentro un ciclo, Dispose verrà chiamato dopo ogni iterazione.


foreach (var path in filePaths)
{
    using var reader = new StreamReader(path);
    // lavoriamo con reader
} // reader.Dispose() viene chiamato dopo ogni iterazione (chiude il file)

6. Errori nel portare codice vecchio

A volte capita che porti codice vecchio o copi un esempio con il using classico, ma la variabile ti serve per più tempo rispetto allo scope delle parentesi. Allora il modo classico non va bene, mentre le dichiarazioni using sono perfette.

Ma ci sono delle sfumature. Ad esempio, se in un ciclo hai due risorse, ma una deve "vivere" più a lungo dell'altra — dichiarale nell'ordine giusto:


using var resource1 = ...;
for (int i = 0; i < 10; i++)
{
    using var resource2 = ...;
    // resource2 vive una sola iterazione
    // resource1 — tutta la funzione
}

7. Pratica

Continuiamo a sviluppare la nostra app didattica — un piccolo simulatore di ordini di caffè che hai migliorato nei giorni scorsi. Ora facciamolo salvare la cronologia degli ordini in un file di testo e leggerli all'avvio.

Passo 1: Salviamo l'ordine su file


using var writer = new StreamWriter("orders.txt", append: true);
writer.WriteLine("Caffè: Latte; Latte: Avena; Dimensione: Grande");

// Il secondo parametro del costruttore StreamWriter append: true indica che vogliamo aggiungere, non sovrascrivere il file.

Passo 2: Leggiamo la cronologia degli ordini


using var reader = new StreamReader("orders.txt");
string? line;
while ((line = reader.ReadLine()) != null)
{
    Console.WriteLine($"Ordine: {line}");
}

E appena il programma finisce di eseguire questo metodo, i file si chiudono automaticamente.

8. Best practice per lavorare con le dichiarazioni using

1. Usa sempre using per oggetti che implementano IDisposable
In .NET la maggior parte delle classi per lavorare con file, stream, risorse implementano questa interfaccia. È un segnale: liberami tramite using!

2. Ricorda lo scope: non dichiarare using-var dove la variabile può "dare fastidio"
Se la variabile ti serve solo per poche righe — usala dove serve, e non prima.

3. Non dimenticare l'ordine di rilascio
Se dichiari più variabili using di fila — Dispose viene chiamato in ordine inverso:


using var first = new Resource("First");
using var second = new Resource("Second");
// ... lavoro
// Prima Dispose per second, poi per first

A volte è importante, se una risorsa dipende dall'altra (ad esempio, lo stream di scrittura deve essere liberato prima del file).

4. Non usare le dichiarazioni using fuori dai metodi
Le dichiarazioni using sono vietate a livello di classe (ad esempio, per i campi). Funzionano solo dentro metodi, costruttori, ecc.

5. Combina con la gestione degli errori
Ricorda che anche con using non tutte le eccezioni sono comode — ha senso aggiungere try-catch se vuoi gestire errori di lettura/scrittura.

2
Compito
C# SELF, livello 36, lezione 0
Bloccato
Lettura di un file usando `using var`
Lettura di un file usando `using var`
Commenti
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION