A C# hibákat exception-ökkel kezeli, melyeket try/catch/finally segítségével lehet megfogni. A megfelelő kivételkezelés azt jelenti, hogy specifikus exception típusokat fogunk meg, felszabadítjuk az erőforrásokat (gyakran using segítségével), értelmes custom exception-öket hozunk létre, és nem elnyomjuk a hibákat csendben.
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)
}
Fogj meg specifikus exception típusokat először, használd az Exception típust végső általános megoldásként, és finally-t a mindig futtatandó tisztításhoz. Fontos: használd a throw; utasítást (nem throw ex;) újradobáshoz — ez megőrzi az eredeti stack trace-t.
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
A using utasítás biztosítja, hogy az IDisposable erőforrások (fájlok, kapcsolatok) megfelelően felszabadulnak — ez az előnyben részesített módja az erőforrások kezelésének, megbízhatóbb, mint a manuális 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
A megfelelő kivételkezelés elengedhetetlen a robusztus és megbízható C# alkalmazások fejlesztéséhez, ezért fontos, hogy alaposan megértsd.
A try/catch/finally szerkezet, specifikus exception típusok megfogása (célzott kezeléshez) az Exception típussal mint végső általános megoldás, és finally a garantált tisztításhoz fundamentális.
Néhány C#-specifikus legjobb gyakorlat különösen fontos: a throw; használata a throw ex; helyett újradobáskor (egy finom, de döntő lépés — a throw ex; alaphelyzetbe állítja a stack trace-t, értékes debug információkat veszítve el), a using utasítás használata IDisposable erőforrásokhoz (az előnyben részesített, megbízható módja annak, hogy fájlok, kapcsolatok és más erőforrások megfelelően felszabadulnak még exception-ök esetén is — megbízhatóbb, mint a manuális finally blokkok, és központi a C# erőforráskezelési modelljében), és az exception-ök csendben történő elnyomásának kerülése.
A kivételkezelés megértése — a szerkezet, specifikus megogások, custom exception-ök, a stack-trace-t megőrző újradobás, és különösen a using az erőforrások kezeléséhez — fontos ahhoz, hogy megbízható C# kódot írj, amely elegánsan kezeli a hibákat és helyesen kezeli az erőforrásokat.
Mivel a kezeletlen exception-ök és erőforrásszivárgások valós megbízhatósági problémákat okoznak, és mivel a C#-nak specifikus idiómái vannak (a using minta, a throw; megőrzése), amelyek megkülönböztetik a robusztus kódot a törékeny kódtól, a kivételkezelés ovládása fontos, gyakran alkalmazott tudás a professzionális C# fejlesztéshez.