Kénapé exception handling bisa gumana?

Question

Accepted Answer

C# nangani errors nganggo **exceptions** sing ditangkep via `try`/`catch`/`finally`. Exception handling sing bener tegese nangkep jenis exception sing spesifik, resik-resiki resources (asring nganggo `using`), gawe custom exceptions sing bermakna, lan ora ngilangake errors kanthi senyep.

## Struktur dasar

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

Nangkep jenis exception sing **spesifik** dhisik, panganggo `Exception` minangka catch-all pungkasan, lan `finally` kanggo resik-resiki sing kudu banter cukup. **Kabar penting:** nganggo `throw;` (dudu `throw ex;`) kanggo throw maneh — iku njaga stack trace asli.

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

## Resik-resiki resources nganggo 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
```

statement **`using`** njamin `IDisposable` resources (files, koneksiones) disposed bener — cara sing luwih disenengi kanggo nangani resik-resiki resources, luwih dipercaya tinimbang `finally` manual.

## Exception filters lan practices 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
```

## Lho apa pentinge

Exception handling sing bener perlu banget kanggo mbentuk aplikasi C# sing kuat, dipercaya, dadi ngerti kanthi lengkap iku kabar penting.

Struktur `try`/`catch`/`finally`, nangkep jenis exception sing **spesifik** (kanggo nangani sing pas target) nganggo `Exception` minangka catch-all pungkasan, lan `finally` kanggo resik-resiki sing dikanteni iku fundamental.

Lerep C#-specific practices kabar penting banget perlu: nganggo **`throw;` tinimbang `throw ex;`** pas throw maneh (rinci nanging kabar penting banget — `throw ex;` reset stack trace, ilang kabar debugging sing berharga), nganggo **`using` statement** kanggo `IDisposable` resources (cara sing disenengi, dipercaya kanggo njamin files, koneksiones, lan resources liyane disposed bener sanajan nalika exceptions metu — luwih kuat tinimbang manual finally blocks, lan sentral ing C# resource-management model), lan ora ngilangake exceptions kanthi senyep.

Ngerti exception handling — struktur, catches spesifik, custom exceptions, throw preserve stack-trace, lan luwihan `using` kanggo resik-resiki resources — iku kabar penting kanggo nulis C# sing dipercaya nangani errors kanthi alus lan ngatur resources kanthi bener.

Amarga unhandled exceptions lan resource leaks nyebabake problems reliability nyata, lan amarga C# nduweni idioms spesifik (`using` pattern, `throw;` preservation) sing mbedakake kode kuat tinimbang kode rapuh, kudu nyepi exception handling iku kabar penting, frequently-applied pengetahuan kanggo professional C# development.