अपवाद हाताळणी कसे कार्य करते?

Question

IT Interview Practice · Accepted Answer

C# ने `try`/`catch`/`finally` द्वारे पकडलेल्या **अपवादांद्वारे** त्रुटी हाताळते. योग्य अपवाद हाताळणी म्हणजे विशिष्ट अपवाद प्रकार पकडणे, संसाधन साफ करणे (बर्‍याचदा `using` सह), अर्थपूर्ण कस्टम अपवाद तयार करणे, आणि त्रुटी शांतपणे दडपून ठेवू नये.

## मूलभूत संरचना

```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` वापरा, आणि नेहमी चालणार असलेल्या साफ करणीसाठी `finally` वापरा. **महत्वाचे:** पुन्हा फेकण्यासाठी `throw;` (फक्त `throw ex;` नव्हे) वापरा — हे मूळ स्टॅक ट्रेस संरक्षित करते.

## अपवाद फेकणे आणि कस्टम अपवाद

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

## 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` संसाधनांना (फाइलें, कनेक्शन) योग्यरित्या विसर्जित करते — हा संसाधन साफ करणीचा प्राधान्य माग, व्यक्तिनिष्ठ `finally` पेक्षा अधिक विश्वसनीय.

## अपवाद फिल्टर आणि सर्वोत्तम अभ्यास

```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
```

## हे महत्वाचे का आहे

योग्य अपवाद हाताळणी मजबूत, विश्वसनीय C# अनुप्रयोग तयार करण्यासाठी आवश्यक आहे, म्हणून याचा गहन समज महत्वाचा आहे.

`try`/`catch`/`finally` संरचना, **विशिष्ट** अपवाद प्रकार पकडणे (लक्षित हाताळणीसाठी) अंतिम कॅच-ऑल म्हणून `Exception` सह, आणि हमी दिलेल्या साफ करणीसाठी `finally` हे मूलभूत आहे.

अनेक C#-विशिष्ट सर्वोत्तम अभ्यास विशेषतः महत्वाचे आहेत: पुन्हा फेकताना **`throw;` `throw ex;` ऐवजी** वापरणे (सूक्ष्म परंतु महत्वाचा तपशील — `throw ex;` स्टॅक ट्रेस रिसेट करते, मूल्यवान डीबगिंग माहिती गमावते), `IDisposable` संसाधनांसाठी **`using` statement** वापरणे (योग्य, विश्वसनीय मार्ग फाइलें, कनेक्शन, आणि इतर संसाधन अपवाद उद्भवून देखील योग्यरित्या साफ करण्यासाठी — व्यक्तिनिष्ठ finally ब्लॉक पेक्षा अधिक मजबूत, आणि C# च्या संसाधन-व्यवस्थापन मॉडेलचे केंद्रबिंदू), आणि अपवाद शांतपणे दडपून ठेवू नये.

अपवाद हाताळणी समजणे — संरचना, विशिष्ट कॅच, कस्टम अपवाद, स्टॅक-ट्रेस-संरक्षण पुन्हा फेकणे, आणि विशेषतः संसाधन साफ करणीसाठी `using` — विश्वसनीय C# लिहिण्यासाठी महत्वाचे आहे जे त्रुटी शालीनपणे हाताळते आणि संसाधन योग्यरित्या व्यवस्थापित करते.

अपरिचालित अपवाद आणि संसाधन रिसाव वास्तविक विश्वसनीयता समस्या निर्माण करतात, आणि C# मध्ये विशिष्ट परिभाषा आहे (`using` नमुना, `throw;` संरक्षण) जे मजबूत कोड नाजुक कोडापासून वेगळे करते, अपवाद हाताळणी मास्टर करणे महत्वाचे आहे, व्यावसायिक C# विकासासाठी वारंवार लागू केलेले ज्ञान आहे.

मूलभूत संरचना

अपवाद फेकणे आणि कस्टम अपवाद

using (IDisposable) सह संसाधन साफ करणे

अपवाद फिल्टर आणि सर्वोत्तम अभ्यास

हे महत्वाचे का आहे

संबंधित प्रश्न