C# hushughulikia makosa kwa exceptions zinazonaswa kupitia try/catch/finally. Exception handling sahihi humaanisha kunasa aina mahususi za exception, kusafisha resources (mara nyingi kwa using), kuunda custom exceptions zenye maana, na kutomeza makosa kwa kimya.
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)
}
Nasa aina mahususi za exception kwanza, tumia Exception kama catch-all ya mwisho, na finally kwa usafishaji ambao lazima ufanyike kila wakati. Muhimu: tumia throw; (si throw ex;) ku-re-throw — inahifadhi stack trace ya asili.
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
using statement huhakikisha resources za IDisposable (files, connections) zinaondolewa ipasavyo — njia inayopendelewa ya kushughulikia usafishaji wa resources, ya kuaminika zaidi kuliko manual 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
Exception handling sahihi ni ya lazima kwa kujenga programu za C# imara na za kuaminika, hivyo kuielewa kwa kina ni muhimu.
Muundo wa try/catch/finally, kunasa aina mahususi za exception (kwa kushughulikia kwa lengo) na Exception kama catch-all ya mwisho, na finally kwa usafishaji uliohakikishwa ni wa msingi.
Best practices kadhaa mahususi za C# ni muhimu hasa: kutumia throw; badala ya throw ex; unapo-re-throw (jambo dogo lakini muhimu — throw ex; huweka upya stack trace, ikipoteza taarifa muhimu za debugging), kutumia using statement kwa resources za IDisposable (njia inayopendelewa, ya kuaminika ya kuhakikisha files, connections, na resources nyingine zinasafishwa ipasavyo hata wakati exceptions zinatokea — imara zaidi kuliko manual finally blocks, na ya kati kwa mfano wa usimamizi wa resources wa C#), na kutomeza exceptions kwa kimya.
Kuelewa exception handling — muundo, catches mahususi, custom exceptions, re-throw inayohifadhi stack-trace, na hasa using kwa usafishaji wa resources — ni muhimu kwa kuandika C# ya kuaminika inayoshughulikia makosa kwa upole na kusimamia resources ipasavyo.
Kwa kuwa exceptions zisizoshughulikiwa na uvujaji wa resources husababisha matatizo halisi ya uaminifu, na kwa kuwa C# ina idioms mahususi (pattern ya using, uhifadhi wa throw;) zinazotofautisha msimbo imara na dhaifu, kumiliki exception handling ni maarifa muhimu, yanayotumika mara kwa mara kwa maendeleo ya kitaaluma ya C#.