விதிவிலக்கு கையாளுதல் எவ்வாறு செயல்படுகிறது?

Question

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` ஐ চূড়ান்த catch-all ஆக பயன்படுத்தவும், மற்றும் `finally` ஐ எப்போதும் இயங்க வேண்டிய சுத்தம் செய்வதற்கு பயன்படுத்தவும். **முக்கியம்:** மீண்டும் எறிய `throw;` (`throw ex;` அல்ல) பயன்படுத்தவும் — இது அசல் stack trace ஐ பாதுகாக்கிறது.

## விதிவிலக்குகளைத் தூக்கிவிடுதல் மற்றும் தனிப்பயன விதிவிலக்குகள்

```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` வளங்களை (கோப்புகள், இணைப்புகள்) சரியாக disposed செய்ய உறுதி செய்கிறது — வளங்களின் சுத்தம் செய்வதற்கான விரும்பத்தக்க வழி, கைமுறை `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 ex;` க்கு பதிலாக `throw;` பயன்படுத்துதல்** (ஒரு நுட்பமான ஆனால் முக்கியமான விস்தரணம் — `throw ex;` stack trace ஐ மீட்டமைக்கிறது, மূল்यवान debugging தகவலை இழக்கிறது), **`using` statement** ஐ `IDisposable` வளங்களுக்கு பயன்படுத்துதல் (விரும்பத்தக்க, நம்பகமான வழி கோப்புகள், இணைப்புகள், மற்றும் பிற வளங்கள் விதிவிலக்குகள் ஏற்பட்டாலும் சரியாக சுத்தம் செய்ய உறுதி செய்ய — கைமுறை finally தொகுப்புகளை விட மிகவும் வலுவான, மற்றும் C#'s வளப்பற்றாக்க மாதிரியின் மையமாக உள்ளது), மற்றும் விதிவிலக்குகளை திண்ணையாக விழுங்காமல் இருப்பதாகும்.

விதிவிலக்கு கையாளுதலைப் புரிந்துகொள்வது — கட்டமைப்பு, குறிப்பிட்ட catches, தனிப்பயன விதிவிலக்குகள், stack-trace-பாதுகாக்கும் மீண்டும் எறிதல், மற்றும் குறிப்பாக வளங்களின் சுத்தம் செய்வதற்கான `using` — நம்பகமான C# எழுத வேண்டியது இதுவே பிழைகளை அனுग्रह செய்ய மற்றும் வளங்களை சரியாக நிர்வகிக்கும்.

கையாளப்படாத விதிவிலக்குகள் மற்றும் வளப் கசிவுகள் உண்மையான நம்பகத்தன்மை சிக்கல்களை ஏற்படுத்தும், மற்றும் C# குறிப்பிட்ட idioms ஐ கொண்டிருக்கும் (`using` முறை, `throw;` பாதுகாப்பு) வலுவான குறியீடு மற்றும் fragile குறியீடு மாறுபட்டிருக்கும், விதிவிலக்கு கையாளுதல் எல்லா நேரங்களிலும் பயன்படுத்தப்படும் கணிசமான C# மேம்பாட்டிற்கான முக்கியமான அறிவாக உள்ளது.