Wat zijn uitzonderingen in de programmeertaal C#?

Exceptions in C# zijn abnormale situaties of fouten die optreden tijdens de uitvoering van een programma en die de normale stroom onderbreken.

Ze maken het mogelijk om foutafhandelingscode te scheiden van de hoofdlogica van de applicatie en bieden een meer gestructureerde aanpak voor foutbeheer.

Belangrijke aspecten van uitzonderingen in C#:

1. Soorten uitzonderingen: C# heeft een hiërarchie van standaard uitzonderingsklassen die erven van de basisklasse System.Exception. Bijvoorbeeld System.NullReferenceException, System.DivideByZeroException, System.IO.FileNotFoundException. Het is ook mogelijk om eigen uitzonderingsklassen te maken.
2. Genereren van uitzonderingen (throw): Een uitzondering wordt gegenereerd met het sleutelwoord throw.
3. Vangen van uitzonderingen (try-catch): Het try-blok bevat code die een uitzondering kan genereren. Het catch-blok vangt een specifiek type uitzondering en voert de code uit om deze te verwerken.
4. Finally-blok: Het finally-blok wordt altijd uitgevoerd, ongeacht of er een uitzondering is gegenereerd of niet. Het wordt vaak gebruikt om bronnen vrij te geven.
5. Using-operator: Een handigere manier om bronnen te beheren, die de aanroep van de Dispose-methode garandeert. Het is vergelijkbaar met de try-finally-constructie voor objecten die de IDisposable-interface implementeren.
6. Uitzonderingsfilters: Hiermee kan een voorwaarde worden toegevoegd aan het catch-blok voor meer specifieke foutafhandeling.

Voorbeeld van gebruik:

public class Example
{
    public void ProcessData(int denominator)
    {
        try
        {
            int result = 10 / denominator; // Kan een DivideByZeroException genereren
            Console.WriteLine($"Resultaat: {result}");
        }
        catch (DivideByZeroException ex) // Vangen van een specifieke uitzondering
        {
            Console.WriteLine("Fout: Kan niet door nul delen.");
            // Log de uitzondering indien nodig
            // Console.WriteLine($"Details van de uitzondering: {ex.Message}");
        }
        catch (Exception ex) // Vangen van alle andere uitzonderingen
        {
            Console.WriteLine($"Er is een onverwachte fout opgetreden: {ex.Message}");
        }
        finally // Dit blok wordt altijd uitgevoerd
        {
            Console.WriteLine("Verwerking voltooid.");
        }
    }

    public void UsingExample()
    {
        // Voorbeeld van gebruik van using voor automatische Dispose-aanroep
        using (StreamReader reader = new StreamReader("file.txt"))
        {
            string line = reader.ReadLine();
            Console.WriteLine(line);
        } // Hier wordt reader.Dispose() automatisch aangeroepen, zelfs als er een uitzondering optreedt
    }

    public void ThrowExample(int value)
    {
        if (value < 0)
        {
            throw new ArgumentOutOfRangeException(nameof(value), "Waarde moet niet-negatief zijn."); // Eigen uitzondering genereren
        }
        // ... verdere logica
    }
}

Het gebruik van uitzonderingen helpt om betrouwbaardere, leesbaardere en onderhoudbare toepassingen te maken, door foutafhandeling van de hoofdlogica te scheiden.