C# gestionează erorile cu excepții capturate prin try/catch/finally. Tratarea corectă a excepțiilor înseamnă captarea tipurilor de excepții specifice, curățarea resurselor (adesea cu using), crearea de excepții personalizate semnificative și nu înăbușirea erorilor în tăcere.
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)
}
Capturați tipuri de excepții specifice mai întâi, folosiți Exception ca catch-all final, și finally pentru curățarea care trebuie să se execute întotdeauna. Important: folosiți throw; (nu throw ex;) pentru a re-arunca — aceasta păstrează stack trace-ul original.
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
Instrucțiunea using asigură că resursele IDisposable (fișiere, conexiuni) sunt corect eliminate — modul preferat de a gestiona curățarea resurselor, mai fiabil decât finally manual.
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
Tratarea corectă a excepțiilor este esențială pentru construirea aplicațiilor C# robuste și fiabile, deci înțelegerea ei aprofundată este importantă.
Structura try/catch/finally, captarea tipurilor de excepții specifice (pentru tratare direcționată) cu Exception ca catch-all final, și finally pentru curățare garantată sunt fundamentale.
Mai multe bune practici specifice C# sunt deosebit de importante: folosirea throw; în loc de throw ex; la re-aruncarea excepțiilor (o detaliu subtilă dar crucială — throw ex; resetează stack trace-ul, pierând informații valoroase de depanare), folosirea declarației using pentru resurse IDisposable (modul preferat și fiabil de a asigura că fișierele, conexiunile și alte resurse sunt corect curățate chiar și atunci când apar excepții — mai robust decât blocurile finally manuale, și central pentru modelul de gestionare a resurselor al C#), și nu înăbușirea excepțiilor în tăcere.
Înțelegerea tratării excepțiilor — structura, capturi specifice, excepții personalizate, re-aruncarea care păstrează stack trace-ul, și în special using pentru curățarea resurselor — este importantă pentru scrierea unui C# fiabil care gestionează erorile cu eleganță și gestionează resursele corect.
Deoarece excepțiile negestionate și scurgerile de resurse cauzeaza probleme reale de fiabilitate, și deoarece C# are idiomuri specifice (modelul using, conservarea throw;) care diferențiază codul robust de codul fragil, stăpânirea tratării excepțiilor este cunoaștere importantă și frecvent aplicată pentru dezvoltarea C# profesională.