Discussion :

[fildentaire]

Bonjour, je commence en C#. je voudrais créer une classe pour traiter mes exceptions.

J'ai donc créer une classe qui dérive de Exception sauf que les erreurs ne sont pas catchées.

code de ma classe:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class TestException : Exception
    {
        public TestException(): base()
        {
        }
        public TestException(string info_ex): base(info_ex)
        {
        }
 
        public void AfficherException()
        {
            Console.WriteLine(this.Message);
            Console.WriteLine(this.StackTrace);
        }
    }

ensuite j'utilise ma classe ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
try { ... }    
           catch (TestException ex) { ex.AfficherException(); }

je pense qu'il y a un truc qui ne va pas mais je ne sais pas pourquoi.
Merci d'avance

[Médinoc]

Peux-tu montrer le code censé lancer une exception de ce type?

Si tu me réponds que tu n'en as pas, c'est que tu n'as pas compris comment les exceptions marchent et pourquoi on crée des exceptions personalisées.

[fildentaire]

le code qui lance le code est de différentes natures.
cela fonctionne lorsque je fait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class TestException
    {
        private Exception e;
public TestException(Exception ex)
        {
            this.e = ex;
        }
        public void AfficherException()
        {
            Console.WriteLine(this.e.Message);
            Console.WriteLine(this.e.StackTrace);
        }
    }

et que le l'utilise :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
try { ... }    
           catch (Exception ex) { new TestException(ex).AfficherException(); }

je voulais créer une classe qui dérive de Exception afin de creer un code plus propre.

[Médinoc]

C'est bien ce qu'il me semblait, cela réclame un cours.

Une classe dérivée de Exception détermine un sous-type d'exception. Ainsi, dans le catch, on peut dire "j'attrape les exceptions de ce type, mais pas les autres".

Un petit exemple:

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
static class Program
{
 
	static int AdditionnerLongueurDesStrings(String[] lesStrings)
	{
		int longueur;
		for(int i=0 ; i<lesStrings.Length ; i++)
			longueur += lesStrings[i].Length;
		return longueur;
	}
 
	static int Main()
	{
		String[] troisStrings = new String[] { "Toto", null, "Titi" };
		try
		{
			int longueur = AdditionnerLongueurDesStrings(troisStrings);
			Console.WriteLine(longueur);
		}
		catch(NullReferenceException e)
		{
			Console.WriteLine("Erreur de reference nulle : " + e.Message);
			return 1;
		}
 
		return 0;
	}
}

Avec ce code, on sait que lorsqu'on va tenter d'obtenir la longueur de la seconde string, une exception NullReferenceException sera automatiquement lancée (parce que la seconde string est nulle). Donc, j'ai mis un catch pour récupérer toutes les exceptions de ce type...

Maintenant, on va modifier le code pour lancer une exception de ton type à la place:

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
static class Program
{

	static int AdditionnerLongueurDesStrings(String[] lesStrings)
	{
		int longueur;
		for(int i=0 ; i<lesStrings.Length ; i++)
		{
			if(lesStrings[i] == null)
				throw new TestException("Une des strings est nulle!");
			longueur += lesStrings[i].Length;
		}
		return longueur;
	}

	static int Main()
	{
		String[] troisStrings = new String[] { "Toto", null, "Titi" };
		try
		{
			int longueur = AdditionnerLongueurDesStrings(troisStrings);
			Console.WriteLine(longueur);
		}
		catch(NullReferenceException e)
		{
			Console.WriteLine("Erreur de reference nulle : " + e.Message);
			return 1;
		}
		catch(TestException e)
		{
			Console.WriteLine("Erreur de type TestException : " + e.Message);
			return 1;
		}

		return 0;
	}
}

Ainsi, si on veut catcher toutes les exceptions possibles, on met un catch(Exception) à la fin. Sachant que dans la liste de catch, il faut commencer par les types les plus dérivés.

[fildentaire]

merci, effectivement je ne voyais pas les exceptions de cette manière.

je voulais simplement modifier le format des informations écrites dans la console une fois l'exception intercepté et que cela marche pour toutes les exceptions (pas de types d'exception en particulier).

je vais revenir à ma seconde idée

[Médinoc]

Dans ce cas, tu n'as pas à créer de type d'exception personalisé, juste ton propre affichage dans le catch()...

[fildentaire]

oui c'est ce que je vais faire.

en java, j'aurais fais ce que je propose au début (mais je me trompe peut etre).

je pensais quand dérivant de la classe Exception, j'aurais les même propriété que la classe mere et que les exceptions seraient catchées de la même manière.

quoi qu'il en soit, mon problème est résolu. merci

[Médinoc]

C'est pareil en C# qu'en java, à ma connaissance, sauf qu'en .Net on ne déclare pas à l'avance les exceptions que peut lancer une fonction.