Fouten afhandelen: try, catch en finally

Waarom foutafhandeling?

Zelfs perfect geschreven code kan fouten tegenkomen: een bestand dat niet bestaat, een netwerk dat uitvalt, een getal dat gedeeld wordt door nul. Als je die fouten negeert, crasht je programma. Met try/catch vang je ze op en handel je ze netjes af.

Basis: try en catch

try
{
    string tekst = File.ReadAllText("tekening.txt");
    Console.WriteLine(tekst);
}
catch (FileNotFoundException ex)
{
    Console.WriteLine($"Bestand niet gevonden: {ex.Message}");
}
catch (UnauthorizedAccessException ex)
{
    Console.WriteLine($"Geen leesrechten: {ex.Message}");
}

C# loopt de catch-blokken van boven naar beneden af en voert het eerste uit dat overeenkomt met het fouttype.

finally: altijd uitgevoerd

Code in finally wordt altijd uitgevoerd — of er nu een fout was of niet. Gebruik het om resources vrij te geven:

StreamReader? lezer = null;
try
{
    lezer = new StreamReader("data.csv");
    Console.WriteLine(lezer.ReadToEnd());
}
catch (Exception ex)
{
    Console.WriteLine($"Fout: {ex.Message}");
}
finally
{
    lezer?.Close();  // wordt altijd uitgevoerd
}

using: resources automatisch vrijgeven

Voor objecten die IDisposable implementeren (bestanden, verbindingen, ...) is using de eenvoudigste manier:

try
{
    using StreamReader lezer = new StreamReader("data.csv");
    Console.WriteLine(lezer.ReadToEnd());
    // lezer wordt automatisch gesloten aan het einde van het using-blok
}
catch (FileNotFoundException)
{
    Console.WriteLine("Bestand niet gevonden.");
}

Een fout gooien (throw)

void SetLayerName(string naam)
{
    if (string.IsNullOrWhiteSpace(naam))
        throw new ArgumentException("Laagnaam mag niet leeg zijn.", nameof(naam));

    // ...
}

Algemene Exception opvangen

Als je niet weet welk type fout er kan optreden, gebruik dan de basisklasse Exception. Zet dit altijd als laatste catch:

catch (FileNotFoundException ex)
{
    // specifiek geval
}
catch (Exception ex)
{
    // alles wat niet hierboven valt
    Console.WriteLine($"Onverwachte fout: {ex.Message}");
}

Best practices

• Vang fouten zo specifiek mogelijk op
• Log de fout (ex.Message, ex.StackTrace) zodat je kunt debuggen
• Gooi nooit een fout weg door een lege catch: catch { } — dit verbergt problemen
• Gebruik finally of using om resources te sluiten

In de volgende post leren we namespaces en hoe je een class library aanmaakt — de basis voor een AutoCAD add-in.

Why error handling?

Even perfectly written code can encounter errors: a file that doesn't exist, a network that fails, a number divided by zero. If you ignore those errors, your program crashes. With try/catch you catch them and handle them gracefully.

Basic: try and catch

try
{
    string text = File.ReadAllText("drawing.txt");
    Console.WriteLine(text);
}
catch (FileNotFoundException ex)
{
    Console.WriteLine($"File not found: {ex.Message}");
}
catch (UnauthorizedAccessException ex)
{
    Console.WriteLine($"No read access: {ex.Message}");
}

finally: always executed

StreamReader? reader = null;
try
{
    reader = new StreamReader("data.csv");
    Console.WriteLine(reader.ReadToEnd());
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}
finally
{
    reader?.Close();  // always runs
}

using: automatic resource cleanup

try
{
    using StreamReader reader = new StreamReader("data.csv");
    Console.WriteLine(reader.ReadToEnd());
    // reader is closed automatically
}
catch (FileNotFoundException)
{
    Console.WriteLine("File not found.");
}

Throwing an error

void SetLayerName(string name)
{
    if (string.IsNullOrWhiteSpace(name))
        throw new ArgumentException("Layer name cannot be empty.", nameof(name));
}

Best practices

• Catch errors as specifically as possible
• Log the error (ex.Message, ex.StackTrace) so you can debug
• Never swallow exceptions with an empty catch: catch { }
• Use finally or using to close resources

In the next post we learn about namespaces and how to create a class library — the foundation of an AutoCAD add-in.