Crearea claselor de excepții

Dacă nu ne convin tipurile de excepții încorporate, putem crea propriile noastre tipuri de excepții. Clasa de bază pentru toate excepțiile este clasa Exception, deci pentru a crea propriile noastre tipuri de excepții, putem moșteni această clasă.

Să presupunem că avem o limită de vârstă în programul nostru:

try
{
   Person person = new Person { Name = "Tom", Age = 17 };
}
catch (Exception ex)
{
   Console.WriteLine($"Eroare: {ex.Message}");
}

class Person
{
   private int age;
   public string Name { get; set; } = "";
   public int Age
   {
       get => age;
       set
       {
           if (value < 18)
               throw new Exception("Persoanelor sub 18 ani nu li se permite înregistrarea");
           else
               age = value;
       }
   }
}

În clasa Person, atunci când se setează vârsta, se efectuează o verificare, și dacă vârsta este mai mică de 18 ani, se aruncă o excepție. Clasa Exception acceptă în constructorul său un șir de caractere, care este apoi transmis proprietății Message.

Dar uneori este mai convenabil să folosim propriile noastre clase de excepții. De exemplu, într-o anumită situație, dorim să tratăm într-un anumit fel doar acele excepții care sunt legate de clasa Person. În acest scop, putem crea o clasă specială PersonException:

class PersonException : Exception
{
   public PersonException(string message)
       : base(message) { }
}

Practic, clasa nu are altceva decât un constructor gol, iar în constructor apelăm constructorul clasei de bază Exception, transmițându-i șirul de caractere message.

Dar acum putem modifica clasa Person pentru a arunca excepții de acest tip și, respectiv, în programul principal să tratăm această excepție:

try
{
   Person person = new Person { Name = "Tom", Age = 17 };
}
catch (PersonException ex)
{
   Console.WriteLine($"Eroare: {ex.Message}");
}

class Person
{
   private int age;
   public string Name { get; set; } = "";
   public int Age
   {
       get => age;
       set
       {
           if (value < 18)
               throw new PersonException("Persoanelor sub 18 ani nu li se permite înregistrarea");
           else
               age = value;
       }
   }
}

Totuși, nu este obligatoriu să moștenim propria clasă de excepții direct din clasa Exception; putem folosi un alt tip derivat. De exemplu, în acest caz putem folosi tipul ArgumentException, care reprezintă o excepție generată ca urmare a transmiterii unei valori incorecte unui argument al unei metode:

class PersonException : ArgumentException
{
   public PersonException(string message)
       : base(message)
   { }
}

Fiecare tip de excepție poate defini propriile sale proprietăți. De exemplu, în acest caz putem defini în clasă o proprietate pentru stocarea valorii setate:

class PersonException : ArgumentException
{
   public int Value { get; }
   public PersonException(string message, int val)
       : base(message)
   {
       Value = val;
   }
}

În constructorul clasei setăm această proprietate și la tratarea excepției o putem accesa:

try
{
   Person person = new Person { Name = "Tom", Age = 17 };
}
catch (PersonException ex)
{
   Console.WriteLine($"Eroare: {ex.Message}");
   Console.WriteLine($"Valoare incorectă: {ex.Value}");
}

class Person
{
   private int age;
   public string Name { get; set; } = "";
   public int Age
   {
       get => age;
       set
       {
           if (value < 18)
               throw new PersonException("Persoanelor sub 18 ani nu

li se permite înregistrarea", value);
           else
               age = value;
       }
   }
}

În acest caz, vom obține următorul rezultat în consolă:

Eroare: Persoanelor sub 18 ani nu li se permite înregistrarea
Valoare incorectă: 17