1. Introduzione
Le operazioni sui file sono quasi sempre legate a circostanze esterne al programma: il file può essere cancellato, spostato, bloccato da un altro programma, l'utente può perdere i permessi o lo spazio su disco può esaurirsi. Tutto questo può portare a eccezioni — situazioni speciali in cui l'esecuzione del programma viene interrotta e viene "lanciato" un oggetto eccezione (Exception). Se non catturi e non gestisci quell'eccezione, il tuo programma terminerà con un errore e mostrerà all'utente un brutto testo rosso nella console (o, peggio — cadrà silenziosamente).
In C# per gestire queste situazioni si usa il blocco try-catch (o, più semplicemente, la "trappola per errori"). Ti permette non solo di "catturare" l'errore, ma anche di decidere serenamente cosa fare dopo: mostrare un messaggio amichevole, proporre di scegliere un altro file, scrivere l'errore nel log o semplicemente riprovare.
Nei progetti reali
Se stai scrivendo una calcolatrice da terminale, probabilmente puoi cavartela senza gestire gli errori sui file. Ma se hai un'app per elaborare documenti in azienda o un gioco che salva lo stato — non gestire questi errori è come camminare su una fune senza imbracatura: prima o poi succederà qualcosa.
2. Richiami sulle eccezioni
Sintassi base di try-catch
Prima di passare alle situazioni concrete con i file, ricordiamo la sintassi base della costruzione try-catch (che abbiamo già visto nelle lezioni sulle eccezioni):
try
{
// Qui il codice che può "lanciare" un'eccezione
}
catch (Exception ex)
{
// Qui catturiamo tutte le eccezioni possibili... Ma è meglio non farlo così!
Console.WriteLine("Qualcosa è andato storto: " + ex.Message);
}
Dentro try scriviamo codice potenzialmente pericoloso, e nel catch cosa fare se qualcosa va storto.
Battuta da programmatore: "try-catch è come un mantello dell'invisibilità per gli errori. L'errore c'è, ma non la vedi!"
Eccezioni sui file
Quando lavori con i file tramite .NET, spesso incontri eccezioni — ad esempio durante la creazione di stream, lettura o scrittura. Ecco alcuni scenari tipici e le eccezioni correlate:
- File non trovato → FileNotFoundException
- Nessun accesso al file/directory → UnauthorizedAccessException
- Problemi con il percorso (es. caratteri non validi, percorso troppo lungo) → PathTooLongException, ArgumentException
- Il file è già usato da un altro processo → IOException
- Spazio su disco insufficiente → IOException
Di solito le operazioni sui file riguardano soprattutto classi derivate da IOException. Tutte ereditano dal tipo base System.Exception.
3. Pratica: catturare e gestire errori con i file
Vediamo casi tipici con gli esempi della nostra "app in crescita": supponiamo di voler leggere un saluto da un file, elaborarlo e mostrarlo all'utente. Aggiungeremo la gestione degli errori con try-catch.
Esempio 1: Gestire "file non trovato"
string filePath = "hello.txt";
try
{
string greeting = File.ReadAllText(filePath);
Console.WriteLine("Contenuto del file: " + greeting);
}
catch (FileNotFoundException ex)
{
Console.WriteLine("File non trovato! Controlla che il file " + filePath + " esista.");
// Possiamo anche mostrare dettagli tecnici
Console.WriteLine("Dettagli tecnici: " + ex.Message);
}
Se il file "hello.txt" non esiste, il programma non terminerà con un errore, ma mostrerà un messaggio amichevole. Così rendiamo il programma resistente agli "errori stupidi" dell'utente.
Esempio 2: Permessi negati
Consideriamo una situazione più complessa: il file c'è, ma non abbiamo i permessi per leggerlo (per esempio qualcuno ha concesso solo permesso di scrittura o il file è in una cartella protetta).
try
{
string secret = File.ReadAllText("C:\\Windows\\System32\\config.txt");
}
catch (UnauthorizedAccessException ex)
{
Console.WriteLine("Nessun accesso al file! Prova a eseguire il programma come amministratore.");
Console.WriteLine("Motivo tecnico: " + ex.Message);
}
Esempio 3: Generica IOException
Alcuni errori possono essere dovuti a conflitti di lock (per esempio un altro processo tiene il file aperto), mancanza di spazio su disco o problemi hardware:
try
{
File.WriteAllText("important.txt", "Informazione importante!");
}
catch (IOException ex)
{
Console.WriteLine("Errore durante l'operazione sul file: probabilmente è usato da un altro programma o lo spazio su disco non è sufficiente.");
Console.WriteLine("Motivo tecnico: " + ex.Message);
}
4. Catturare più eccezioni: gestione selettiva
A volte serve reagire in modo diverso a diversi tipi di eccezioni. In .NET è permesso specificare più blocchi catch — dal più specifico al più generale (altrimenti il compilatore farà la tua codice sciopero rumoroso alla italiana).
try
{
string content = File.ReadAllText("file.txt");
Console.WriteLine(content);
}
catch (FileNotFoundException ex)
{
Console.WriteLine("File non trovato.");
}
catch (UnauthorizedAccessException ex)
{
Console.WriteLine("Nessun accesso al file!");
}
catch (IOException ex)
{
Console.WriteLine("Altro errore di I/O: " + ex.Message);
}
Importante: se metti catch (Exception ex) per primo, gli altri blocchi non avranno senso, perché il tipo base catturerà tutto!
5. Try-catch annidati e retry
Qualche volta vuoi non solo gestire l'errore, ma dare all'utente la possibilità di "rimediare" — per esempio chiedere di inserire il percorso di un file esistente:
string filePath;
string content;
int attempts = 0;
const int maxAttempts = 3;
do
{
Console.Write("Inserisci il percorso del file: ");
filePath = Console.ReadLine();
try
{
content = File.ReadAllText(filePath);
Console.WriteLine("Contenuto del file:\n" + content);
break;
}
catch (FileNotFoundException)
{
Console.WriteLine("File non trovato! Riprova.");
}
catch (UnauthorizedAccessException)
{
Console.WriteLine("Nessun accesso al file! Prova un altro file.");
}
attempts++;
}
while (attempts < maxAttempts);
if (attempts == maxAttempts)
Console.WriteLine("Troppe tentativi falliti.");
Questo codice è una piccola "interfaccia amichevole" per l'utente che ha dimenticato dove ha salvato il file.
6. Errori tipici e particolarità: dalla pigrizia alla consapevolezza
Un errore molto comune dei principianti (e anche di sviluppatori esperti) è catturare tutte le eccezioni in blocco, scrivendo semplicemente catch (Exception) e stampando "Si è verificato un errore!", senza pensare alle cause. Questo approccio è pessimo per diversi motivi. Primo, nasconde bug reali nella business logic dell'applicazione. Secondo, altri errori non correlati ai file (es. refusi nel codice o errori matematici) possono essere accidentalmente inghiottiti, e trovare la causa reale richiederà molto tempo.
È molto meglio — catturare esplicitamente solo gli errori che sai gestire in modo sensato. Se non sei sicuro di quale errore sia successo, è preferibile lasciare che l'eccezione "cada" — cioè non catturarla: lascia che l'applicazione fallisca, così vedrai lo stack trace e capirai cosa sistemare.
Particolarità: alcune eccezioni possono avere cause annidate (InnerException). Analizzarle è utile per una diagnostica più dettagliata, specialmente quando scrivi i log degli errori.
Un altro punto: se dopo un blocco catch la vita del programma non ha senso (per esempio non si è riusciti ad aprire il file di configurazione principale), puoi terminare l'esecuzione con return o rilanciare l'eccezione (throw;) per non creare "programmi zombie" con funzionalità a metà.
GO TO FULL VERSION