> For the complete documentation index, see [llms.txt](https://apwt.gitbook.io/zie-scherp-scherper/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://apwt.gitbook.io/zie-scherp-scherper/h14-gevorderde-overervingsconcepten/1_eigenuitzondering.md).

# Eigen exceptions maken

We zijn ondertussen al gewend aan het opvangen van uitzonderingen met behulp van `try` en `catch`. Ook bij exception handling wordt overerving toegepast. De uitzonderingen die we opvangen zijn steeds objecten van het type `Exception` of van een afgeleide klasse. Denk maar aan de `NullReferenceException` klasse die werd overgeërfd van `Exception`.

{% hint style="info" %}
Dat wil zeggen dat `Exception`s ook maar "gewone klassen" zijn en dus ook aan alle andere regels binnen C# moeten voldoen. Zo ondersteunen ze polymorfisme (*sooooon!*), kan je ze in arrays plaatsen, enz.
{% endhint %}

Bijgevolg is het logisch dat je in je code **uitzonderingen zelf kunt maken en opwerpen**. Vervolgens kan je deze elders opvangen.

Een voorbeeld van een bestaand `Exception` type gebruiken. We gaan zelf een `Exception` object aanmaken (met `new`) en dit vervolgens opwerpen wanneer we een uitzondering opmerken. In dit geval wanneer `getal` de waarde `0` heeft:

```csharp
static int ResultaatBerekening(int getal)
{
    if (getal != 0)
        return 100 / getal;
    else
        throw new DivideByZeroException("BOEM. ZWART GAT!");
}
 
 
static void Main(string[] args)
{
    try
    {
        Console.WriteLine(ResultaatBerekening(0));
    }
    catch(DivideByZeroException e)
    {
        Console.WriteLine(e.Message);
    }
}
```

De uitvoer zal zijn:

```
BOEM. ZWART GAT!
```

De lijn `throw new DivideByZeroException("BOEM. ZWART GAT!");` zorgt er dus voor dat we een eigen foutboodschap verpakken en opwerpen.

## Een eigen exception ontwerpen

Je kan ook eigen klassen overerven van `Exception` zodat je eigen uitzonderingen kan maken. Je maakt hiervoor gewoon een nieuwe klasse aan die je laat overerven van de Exception-klasse. Een voorbeeld:

```csharp
internal class Timception: Exception
{
    public override string ToString()
    {
        string extrainfo = "Exception Generated by Tim Dams:\n";
        return $"{extrainfo}. {base.ToString()}";
    }
}
```

{% hint style="info" %}
Merk op dat we hier met `base.ToString()` ervoor zorgen dat ook de foutboodschap van het parent-gedeelte van de uitzondering wordt weergegeven.
{% endhint %}

Om deze exception nu zelf op te werpen gebruiken we het keyword **`throw`** gevolgd door een object van het type uitzondering dat je wenst op te werpen.

In volgende voorbeeld gooien we onze eigen exception op een bepaald punt in de code op en vangen deze dan op:

```csharp
static void Main(string[] args)
{
    try
    {
        TimsMethode();
    }
 
    catch (Timception e)
    {
       Console.WriteLine(e.ToString());
    }     
}
static public void TimsMethode()
{
    //doe dingen
    //...
    //"when suddenly: a wild exception appears"
    throw new Timception();
}
```


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://apwt.gitbook.io/zie-scherp-scherper/h14-gevorderde-overervingsconcepten/1_eigenuitzondering.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `build a script that syncs our docs to a CMS` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.