C# try/catch/finally ద్వారా పట్టిన exceptions ఉపయోగించి లోపాలను నిర్వహిస్తుంది. సరైన exception handling అంటే నిర్దిష్ట exception types కలిగి ఉండటం, resources శుభ్రపరచడం (తరచుగా using తో), అర్థవంతమైన custom exceptions సృష్టించడం, మరియు లోపాలను నిశ్శబ్దంగా గ్రహిస్తూ ఉండకపోవడం.
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)
}
నిర్దిష్ట exception types ముందుగా catch చేయండి, చివరి catch-all గా Exception ఉపయోగించండి, మరియు finally సర్వదా నడిచాలసిన cleanup కోసం. ముఖ్యమైనది: re-throw చేయడానికి throw; ఉపయోగించండి (not throw ex;) — ఇది అసలైన 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` 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) సరిగ్గా disposed చేయబడతాయని నిশ్చితం చేస్తుంది — manual finally కంటే resources నిర్వహించడానికి ఉత్తమ మార్గం.
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 structure, నిర్దిష్ట exception types (లక్ష్యిత నిర్వహణ కోసం) చివర catch-all గా Exception తో, మరియు guaranteed cleanup కోసం finally అనేవి ప్రాథమిక.
వివిధ C#-నిర్దిష్ట best practices ముఖ్యమైనవి: re-throwing సమయంలో throw; కంటే throw ex; ఉపయోగించకుండా (సూక్ష్మమైన కానీ కీలకమైన వివరం — throw ex; stack trace రీసెట్ చేస్తుంది, విలువైన debugging సమాచారం కోల్పోతుంది), IDisposable resources కోసం using statement ఉపయోగించడం (ఉత్తమ, నమ్మకమైన మార్గం files, connections, మరియు ఇతర resources exceptions సంభవించినప్పటికీ సరిగ్గా cleaned up చేయబడతాయని నిశ్చితం చేయడానికి — manual finally blocks కంటే మరింత బలిష్ఠమైన, మరియు C#'s resource-management modelకు కేంద్రీయమైనది), మరియు exceptions నిశ్శబ్దంగా గ్రహించకుండా.
Exception handling అర్థం చేసుకోవడం — structure, specific catches, custom exceptions, stack-trace-preserving re-throw, మరియు ముఖ్యంగా resource cleanup కోసం using — నమ్మకమైన C# రాయడానికి ముఖ్యమైనది, ఇది gracefully errors నిర్వహిస్తుంది మరియు resources సరిగ్గా నిర్వహిస్తుంది.
Unhandled exceptions మరియు resource leaks నిజమైన reliability సమస్యలను కలిగిస్తాయి, మరియు C# నిర్దిష్ట idioms (the using pattern, throw; preservation) కలిగి ఉంది, ఇవి బలిష్ఠమైన కోడ్ నుండి బలహీన కోడ్ ను విభజిస్తాయి, exception handling నిపుణుడిని సాధించడం ముఖ్యమైనది, తరచుగా-అన్వయించిన జ్ఞానం professional C# development కోసం.
జూనియర్ నుండి సీనియర్ వరకు వివరణాత్మక సమాధానాలతో IT ఇంటర్వ్యూ ప్రశ్నల లైబ్రరీ.
విరాళం