Discussion :

[movlw]

Bonjour, j'ai besoin de votre conseil pour un développement de logiciel en C#:

j'ai un programme qui exécute plusieurs fonctions et j'aimerai créer un suivi d’exécution des fonctions et enregistrer des résultats de conversion et d'exceptions.

Lorsque j'effectue une conversion dans une des fonctions l’exécution renvoi un booleen (true ou false). Lorsque la conversion échoue j'aimerai l'enregistrer dans une variable pour pouvoir la vérifier plus tard et remonter une erreur à l'utilisateur.

j'ai d'abord penser a une structure globale du type :

Code :

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

1
2
3
4
5
6
struct errorManager 
{
     bool bErrorOccured=false;
     int iErrorLevel = 0;
     string sErrorDescription="";
}

Je ne sais pas si ma solution est la plus adaptée. Quen pensez vous ?

[ericlm128]

Si il s'agit d'exception tu peux les stocker dans une liste d'exception.

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
16
17
18
19
20
21
List<Exception> Exceptions = new List<Exception>();
try
{
    int a = int.Parse("a");
}
catch (Exception ex)
{
    Exceptions.Add(ex);
}
 
try
{
    int a = int.Parse("bb");
}
catch (Exception ex)
{
    Exceptions.Add(ex);
}
 
foreach (Exception ex in Exceptions)
    MessageBox.Show(ex.ToString());

Si ça ne correspond pas à tes attentes merci de préciser et nous montrer ta fonction de conversion.

[DiOxy]

Salut,

Concernant ton code, il pose un problème car tu ne peux pas initialiser les champs d'un type struct.
Voila comment tu peux faire (Au passage, désolé, je n'ai pas pu m'empêcher de rajouter un enum :p) :

J'ai récupéré le code de ericlm128 pour te créer l'exemple suivant.

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
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
using System;
using System.Collections.Generic;
 
namespace ConsoleApplication1
{
    public enum enErrorLevel
    {
        none,
        warning,
        simple,
        critical
    }
 
    public struct stErrorManager
    {
        public bool bErrorOccured;
        public enErrorLevel iErrorLevel;
        public string sErrorDescription;
 
        public stErrorManager(bool errorOccured, enErrorLevel errorLevel, string errorDescription)
        {
            bErrorOccured = errorOccured;
            iErrorLevel = errorLevel;
            sErrorDescription = errorDescription;
        }
    }
 
    class Program
    {
        static void Main(string[] args)
        {
            List<stErrorManager> listeErrors = new List<stErrorManager>();
 
            try
            {
                int a = int.Parse("a");
            }
            catch (Exception ex)
            {
                listeErrors.Add(new stErrorManager(true, enErrorLevel.simple, ex.Message));
            }
 
            try
            {
                int a = int.Parse("bb");
            }
            catch (Exception ex)
            {
                listeErrors.Add(new stErrorManager(true, enErrorLevel.critical, ex.Message));
            }
 
            foreach (stErrorManager em in listeErrors)
            {
                Console.WriteLine("Erreur {0} - Message : {1}", em.iErrorLevel, em.sErrorDescription);
            }
 
            Console.ReadKey();
        }
    }
}

Voilà le résultat :

Erreur simple - Message : Le format de la chaîne d'entrée est incorrect.
Erreur critical - Message : Le format de la chaîne d'entrée est incorrect.

Tu peux également ajouter dans ta struct un champ pour indiquer plus précisément l'endroit ou se trouve le problème, comme par exemple le nom de la fonction appelante.
Personnellement, rien ne m'énerve plus qu'un message du genre : Erreur 41524. Je préfère que mes clients lisent un message plus explicite permettant de mieux les guider pour les dépanner.

Amicalement