Bagaimanakah pengendalian pengecualian (exception handling) berfungsi?

Question

Accepted Answer

C# mengendalikan ralat dengan **pengecualian** yang ditangkap melalui `try`/`catch`/`finally`. Pengendalian pengecualian yang betul bermaksud menangkap jenis pengecualian yang spesifik, membersihkan sumber (selalunya dengan `using`), mencipta pengecualian tersuai yang bermakna, dan tidak menelan ralat secara senyap.

## Struktur asas

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

Tangkap jenis pengecualian **spesifik** dahulu, gunakan `Exception` sebagai penangkap-semua terakhir, dan `finally` untuk pembersihan yang mesti sentiasa berjalan. **Penting:** gunakan `throw;` (bukan `throw ex;`) untuk membaling semula — ia mengekalkan jejak tindanan (stack trace) yang asal.

## Membaling dan pengecualian tersuai

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

## Pembersihan sumber dengan 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
```

**Pernyataan `using`** memastikan sumber `IDisposable` (fail, sambungan) dilupuskan dengan betul — cara yang diutamakan untuk mengendalikan pembersihan sumber, lebih boleh dipercayai daripada `finally` manual.

## Penapis pengecualian dan amalan terbaik

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

## Mengapa ia penting

Pengendalian pengecualian yang betul adalah penting untuk membina aplikasi C# yang teguh dan boleh dipercayai, jadi memahaminya dengan teliti adalah penting.

Struktur `try`/`catch`/`finally`, menangkap jenis pengecualian **spesifik** (untuk pengendalian bersasar) dengan `Exception` sebagai penangkap-semua terakhir, dan `finally` untuk pembersihan terjamin adalah asas.

Beberapa amalan terbaik khusus C# amat penting: menggunakan **`throw;` dan bukannya `throw ex;`** apabila membaling semula (butiran yang halus tetapi kritikal — `throw ex;` menetapkan semula jejak tindanan, menghilangkan maklumat penyahpepijatan yang berharga), menggunakan **pernyataan `using`** untuk sumber `IDisposable` (cara yang diutamakan dan boleh dipercayai untuk memastikan fail, sambungan, dan sumber lain dibersihkan dengan betul walaupun apabila pengecualian berlaku — lebih teguh daripada blok finally manual, dan pusat kepada model pengurusan sumber C#), dan tidak menelan pengecualian secara senyap.

Memahami pengendalian pengecualian — strukturnya, penangkapan spesifik, pengecualian tersuai, pembalingan semula yang mengekalkan jejak tindanan, dan terutamanya `using` untuk pembersihan sumber — adalah penting untuk menulis C# yang boleh dipercayai yang mengendalikan ralat dengan baik dan menguruskan sumber dengan betul.

Memandangkan pengecualian yang tidak dikendalikan dan kebocoran sumber menyebabkan masalah kebolehpercayaan yang sebenar, dan memandangkan C# mempunyai idiom khusus (corak `using`, pengekalan `throw;`) yang membezakan kod yang teguh daripada kod yang rapuh, menguasai pengendalian pengecualian ialah pengetahuan penting yang kerap diterapkan untuk pembangunan C# yang profesional.