Hvordan fungerer exception handling?

Question

Accepted Answer

C# håndterer fejl med **exceptions** fanget via `try`/`catch`/`finally`. Korrekt exception handling betyder at fange specifikke exception-typer, rydde op i ressourcer (ofte med `using`), oprette meningsfulde custom exceptions, og ikke undertrykke fejl stille og roligt.

## Grundlæggende struktur

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

Fang **specifikke** exception-typer først, brug `Exception` som en final catch-all, og `finally` for rydning som altid skal køre. **Vigtigt:** brug `throw;` (ikke `throw ex;`) til at gen-kaste — det bevarer det oprindelige stack trace.

## At kaste og 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");
```

## Ressourcerydning med 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`-statementet** sikrer at `IDisposable`-ressourcer (filer, forbindelser) korrekt disponeres — den foretrukne måde at håndtere ressourcerydning, mere pålidelig end manuel `finally`.

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

## Hvorfor det betyder noget

Korrekt exception handling er essentielt for at bygge robuste, pålidelige C#-applikationer, så det er vigtigt at forstå det grundigt.

Structuren `try`/`catch`/`finally`, fangning af **specifikke** exception-typer (til målrettet håndtering) med `Exception` som en final catch-all, og `finally` for garanteret rydning er grundlæggende.

Flere C#-specifikke best practices er særlig vigtige: at bruge **`throw;` i stedet for `throw ex;`** når man gen-kaster (en subtil men afgørende detalje — `throw ex;` nulstiller stack tracet, hvilket mister værdifuld debugging-information), at bruge **`using`-statementet** for `IDisposable`-ressourcer (den foretrukne, pålidelige måde at sikre at filer, forbindelser og andre ressourcer korrekt ryddes selv når exceptions opstår — mere robust end manuel finally-blokke, og centrale for C#'s ressource-håndteringsmodel), og ikke at undertrykke exceptions stille og roligt.

At forstå exception handling — strukturen, specifikke catches, custom exceptions, stack-trace-bevarende gen-kast, og især `using` til ressourcerydning — er vigtigt for at skrive pålidelig C#, der håndterer fejl elegant og styrer ressourcer korrekt.

Da uhåndterede exceptions og ressourcelekager forårsager rigtige pålidelighedsproblemer, og da C# har specifikke idiomer (`using`-mønsteret, `throw;`-bevaring) der skelner robust kode fra skrøbelig kode, er det at mestre exception handling vigtig, hyppigt-anvendt viden for professionel C#-udvikling.