Láimhsíonn C# earráidí le eisceachtaí a bhailítear trí try/catch/finally. Is éard atá i láimhseáil eisceachtaí cheart ná cineálacha eisceachtaí sonracha a bhreith, acmhainní a ghlanadh (go minic le using), eisceachtaí custaim bhríathartha a chruthú, agus earráidí a bheith gan a bheith ag súathadh go ciúin.
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)
}
Breith ar chineálacha sonracha eisceachtaí ar dtús, Exception a úsáid mar bhreith-geal deiridh, agus finally do ghlanadh a chaithfidh i gcónaí a rith. Tábhachtach: úsáid throw; (ní throw ex;) chun athaiseag a dhéanamh — coimeádann sé an lorg cruachais bhunaidh.
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
Cinntíonn an ráiteas using go ndéantar acmhainní IDisposable (comhaid, naisc) a dhúnadh go cuí — an bealach is fearr chun glanadh acmhainní a láimhseáil, níos iontaofa ná finally láimhe.
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
Is ionann láimhseáil ceart eisceachtaí agus fúinneamh a thógáil chun feidhmchláir dhocht, iontaofa C# a thógáil, agus dá bhrí sin tá sé tábhachtach go dtuigeann tú é go mion.
Tá an struchtúr try/catch/finally, breith ar chineálacha sonracha eisceachtaí (do láimhseáil dhírithe) le Exception mar bhreith-geal deiridh, agus finally do ghlanadh athrialaithe bunúsach.
Tá roinnt dea-chleachtais ar leith ar C# an-tábhachtach: throw; a úsáid seachas throw ex; nuair a bhíonn tú ag athaiseag (mion-rud ach rud ríthábhachtach — cuireann throw ex; an lorg cruachais athchur ar foluain, ag cailleadh faisnéise dhíobhálacha dhífhostú), an ráiteas using a úsáid do acmhainní IDisposable (an bealach is fearr, iontaofa chun a chinntiú go ndéantar comhaid, naisc, agus acmhainní eile a dhúnadh go cuí fiú nuair a bhíonn eisceachtaí ann — níos daingne ná bloic finally láimhe, agus ionad i lár páirc le muinín C# do bhainistiú acmhainní), agus gan eisceachtaí a bheith ag súathadh go ciúin.
A thuiscint ar láimhseáil eisceachtaí — an struchtúr, breith ar leith, eisceachtaí custaim, an athaiseag a chaomhnaíonn an lorg cruachais, agus go háirithe using do ghlanadh acmhainní — is tábhachtach é chun C# iontaofa a scríobh a láimhsíonn earráidí go dea-ghéillí agus a bhainistíonn acmhainní i gceart.
Toisc go bhfuil earráidí agus sceilbheadh acmhainní gan láimhseáil ina gcúis dearúd fíordhrámhata iontaofa, agus toisc go bhfuil idéanna ar leith ar C# (an patrún using, caomhnú throw;) ann a dhéanann idirdhealú idir cód daingean agus cód aimealach, is cúis léir é láimhseáil eisceachtaí a bhheith ar do thoil, eolas atá i bhfeidhm go minic chun forbairt ghairmiúil C# a dhéanamh.