CodeGym /Corsi /C# SELF /Gestione delle eccezioni sui file ( try-catch)

Gestione delle eccezioni sui file ( try-catch)

C# SELF
Livello 38, Lezione 1
Disponibile

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à.

2
Compito
C# SELF, livello 38, lezione 1
Bloccato
Gestione di più eccezioni durante la scrittura su file
Gestione di più eccezioni durante la scrittura su file
Commenti
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION