Exception handling ఎలా పని చేస్తుంది?

Question

Accepted Answer

C# `try`/`catch`/`finally` ద్వారా పట్టిన **exceptions** ఉపయోగించి లోపాలను నిర్వహిస్తుంది. సరైన exception handling అంటే నిర్దిష్ట exception types కలిగి ఉండటం, resources శుభ్రపరచడం (తరచుగా `using` తో), అర్థవంతమైన custom exceptions సృష్టించడం, మరియు లోపాలను నిశ్శబ్దంగా గ్రహిస్తూ ఉండకపోవడం.

## The basic structure

```csharp
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 సంరక్షిస్తుంది.

## Throwing and custom exceptions

```csharp
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");
```

## Resource cleanup with using (IDisposable)

```csharp
// `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 నిర్వహించడానికి ఉత్తమ మార్గం.

## Exception filters and best practices

```csharp
catch (Exception ex) when (ex.Message.Contains("timeout"))   // exception filter (when)
{ ... }
```

```text
✓ 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 కోసం.