C# exceptions વાપરીને errors સંભાળે છે જે try/catch/finally થી પકડવામાં આવે છે. સાચી exception handling એટલે specific exception types પકડવા, resources સાફ કરવા (ઘણીવાર using સાથે), meaningful custom exceptions બનાવવા, અને errors ને silence માં ગળી જવાનું નહી.
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)
}
Specific exception types પહેલાં પકડો, Exception ને final catch-all તરીકે વાપરો, અને cleanup માટે finally વાપરો જે હમેશા ચાલવું જોઈએ. મહત્વપૂર્ણ: throw; વાપરો (નહીં throw ex;) પુનः throw કરવા માટે — તે મૂળ stack trace સંરક્ષિત રાખે છે.
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 (IDisposable) સાથે resource cleanup// `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 IDisposable resources (files, connections) ને યોગ્યરીતે dispose કર્યા જાય તેની ખાતરી કરે છે — resource cleanup સંભાળવાનો સુધારેલ રીત, 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 મજબૂત, વિશ્વાસપાત્ર C# applications બનાવવા માટે આવશ્યક છે, તેથી તેને સારી રીતે સમજવું મહત્વપૂર્ણ છે.
try/catch/finally બંધારણ, specific exception types (targeted handling માટે) specific સાથે પકડવા અને Exception ને final catch-all તરીકે, અને guaranteed cleanup માટે finally ભૌતિક છે.
ઘણી C#-specific best practices ખાસ મહત્વપૂર્ણ છે: re-throw કરતી વખતે throw; rather than throw ex; વાપરવું (એક સૂક્ષ્મ પણ નિર્ણાયક વિગત — throw ex; stack trace ને reset કરે છે, મૂલ્યવાન debugging માહિતી ગુમાવે છે), IDisposable resources માટે using statement વાપરવું (preferred, વિશ્વાસપાત્ર રીત files, connections, અને અન્ય resources ને યોગ્યરીતે cleanup કર્યા જાય તેની ખાતરી કરવા — manual finally blocks કરતાં વધુ મજબૂત, અને C#ના resource-management model માટે કેન્દ્રીય), અને exceptions ને silence માં ગળી જવું નહી.
Exception handling સમજવું — બંધારણ, specific catches, custom exceptions, stack-trace-preserving re-throw, અને ખાસ કરીને using resource cleanup માટે — મહત્વપૂર્ણ છે reliable C# લખવા માટે જે gracefully errors સંભાળે છે અને resources યોગ્યરીતે વ્યવસ્થાપિત કરે છે.
જ્યારે unhandled exceptions અને resource leaks વાસ્તવિક reliability સમસ્યાઓ ઉત્પન્ન કરે છે, અને જ્યારે C# પાસે specific idioms છે (using pattern, throw; preservation) જે મજબૂત code ને નાજુક code થી અલગ પાડે છે, exception handling માટે માનક કરવું મહત્વપૂર્ણ છે, professional C# development માટે વારંવાર-લાગુ કરવાયેલ જ્ઞાન.