C# gestisce gli errori con eccezioni catturate tramite try/catch/finally. Una corretta gestione delle eccezioni significa catturare tipi di eccezione specifici, pulire le risorse (spesso con using), creare eccezioni personalizzate significative e non ingoiare gli errori silenziosamente.
try
{
var data = RiskyOperation();
}
catch (FileNotFoundException ex) // catch SPECIFIC types (most specific first)
{
Console.WriteLine($"File missing: {ex.Message}");
}
catch (IOException ex)
{
Log(ex);
throw; // re-throw, PRESERVING the stack trace (not `throw ex`)
}
catch (Exception ex) // catch-all (last) — base of all exceptions
{
Log(ex);
}
finally
{
Cleanup(); // ALWAYS runs (success, exception, or return)
}
Cattura i tipi di eccezione specifici per primi, usa Exception come catch-all finale, e finally per la pulizia che deve sempre eseguirsi. Importante: usa throw; (non throw ex;) per ri-lanciare — preserva lo stack trace originale.
if (amount < 0)
throw new ArgumentException("Amount must be positive", nameof(amount));
// a custom exception for your domain
public class InsufficientFundsException : Exception
{
public InsufficientFundsException(string message) : base(message) { }
}
throw new InsufficientFundsException("Balance too low");
// `using` guarantees Dispose() is called (close files/connections) even on exception
using (var file = new StreamReader("data.txt"))
{
var content = file.ReadToEnd();
} // file.Dispose() called automatically here
using var conn = new SqlConnection(...); // C# 8 simplified form
L'istruzione using assicura che le risorse IDisposable (file, connessioni) siano correttamente eliminate — il modo preferito per gestire la pulizia delle risorse, più affidabile di un manuale finally.
catch (Exception ex) when (ex.Message.Contains("timeout")) // exception filter (when)
{ ... }
✓ Catch SPECIFIC exceptions, not just Exception
✓ Use `using` for IDisposable resources (reliable cleanup)
✓ Don't swallow exceptions silently (empty catch) — log or re-throw
✓ Use `throw;` (not `throw ex;`) to preserve the stack trace
✓ Create meaningful custom exceptions; don't use exceptions for normal control flow
Una corretta gestione delle eccezioni è essenziale per costruire applicazioni C# robuste e affidabili, quindi comprenderla a fondo è importante.
La struttura try/catch/finally, catturare tipi di eccezione specifici (per una gestione mirata) con Exception come catch-all finale, e finally per una pulizia garantita sono fondamentali.
Alcune best practice specifiche di C# sono particolarmente importanti: usare throw; piuttosto che throw ex; quando si ri-lancia (un dettaglio sottile ma cruciale — throw ex; resetta lo stack trace, perdendo informazioni di debug preziose), usare l'istruzione using per risorse IDisposable (il modo preferito e affidabile per assicurare che file, connessioni e altre risorse siano correttamente pulite anche quando si verificano eccezioni — più robusto di blocchi finally manuali, e centrale al modello di gestione delle risorse di C#), e non ingoiare eccezioni silenziosamente.
Comprendere la gestione delle eccezioni — la struttura, i catch specifici, le eccezioni personalizzate, il ri-lancio che preserva lo stack trace, e soprattutto using per la pulizia delle risorse — è importante per scrivere C# affidabile che gestisce gli errori elegantemente e gestisce le risorse correttamente.
Poiché le eccezioni non gestite e le perdite di risorse causano veri problemi di affidabilità, e poiché C# ha idiomi specifici (il pattern using, la preservazione di throw;) che distinguono il codice robusto da quello fragile, padroneggiare la gestione delle eccezioni è una conoscenza importante e frequentemente applicata per lo sviluppo professionale di C#.