[Débutant] Gestion d'erreur et ENUM

Gestion d'erreur et ENUM

Bonjour

Contexte : Visual Studio 2015, C#

je suis en train de chercher pourquoi le code suivant ne déclenche pas une exception.
En effet, je caste un "integer" en "enum" en passant une valeur ne faisant pas partie de la collection.
Peut être que ce comportement est normal, ou bien alors, n'étant pas très fort en C#, j'ai fait une ou des erreurs dans mon code.
Merci pour tout conseils.

Dans le fichier ProcessusType.cs

Code:

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
namespace VisualProcessus
{
    enum Family
    {
        Simple = 0,
        Message = 1,
        File = 2
    }
 
    enum Simple
    {
        Boolean = 0,
        Integer = 1,
        Decimal = 2,
        String = 3,
        Time = 4,
        Date = 5,
        Timestamp = 6
    }
 
    enum Message
    {
        System = 0,
        State = 1,
        Mail = 2,
        SMS = 3
    }
 
    enum File
    {
        Texte = 0,
        Spreadsheet = 1,
        Multimedia = 2,
        Data = 3
    }
 
    class ProcessusType
    { ......

Dans le fichier ProcessusDescription.cs

Code:

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace VisualProcessus
{
    public class ProcessusDescription
    {
        private string _sId;
        private string _sName;
        private string _sDescription;
        private string _cContainerType;
        private Family _fFamily;
        private int _iSubType;
 
        public string Name
        {
            get
            {
                return _sName;
            }
 
            set
            {
                _sName = value;
            }
        }
 
        public string Description
        {
            get
            {
                return _sDescription;
            }
 
            set
            {
                _sDescription = value;
            }
        }
 
        public string ContainerType
        {
            get
            {
                return _cContainerType;
            }
 
            set
            {
                try
                {
                    _cContainerType = value;
                    _fFamily = (Family)(value[0] - '0');
                    switch ((Family)_fFamily)
                    {
                        case Family.Simple:
                            _iSubType = (int)((Simple)(value[1] - '0'));
                            break;
                        case Family.Message:
                            _iSubType = (int)((Message)(value[1] - '0'));
                            break;
                        case Family.File:
                            _iSubType = (int)((File)(value[1] - '0'));
                            break;
                        default:
                            throw new VisualProcessusException("Erreur de type 'ContainerType'.");
 
                    }
                }
                catch (VisualProcessusException ex)
                {
                    ex.DisplayError();
                }
            }
        }
 
        public ProcessusDescription(string sId)
        {
            _sId = sId;
        }
 
        public ProcessusDescription(string sId, string sName)
        {
            _sId = sId;
            _sName = sName;
        }
 
        public ProcessusDescription(string sId, string sName, string sDescription)
        {
            _sId = sId;
            _sName = sName;
            _sDescription = sDescription;
        }
    }
}

Le fichier console de test :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using VisualProcessus;
 
namespace Test
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Test de l'erreur applicative");
            ProcessusDescription pd = new ProcessusDescription("001");
            pd.ContainerType = "55";
        }
    }
}

A noter que la valeur passée ("55") est en dehors des collections "enum" définie dans le fichier ProcessusType.
Il me semble que le code "_fFamily = (Family)(value[0] - '0');" devrait générer une exception, alors que l'erreur est gérée par le "default" du switch.

Bonjour,

Ce comportement, bien que surprenant, est normal. Un enum n'est qu'en réalité un entier. C'est d'ailleurs pour cela qu'on peut le caster depuis/vers un entier sans problème.

Maintenant, pourquoi est-ce qu'il est autorisé d'avoir des valeurs non définies ? C'est pour pouvoir supporter les enum de type flag, où on ne définit pas toutes les valeurs, mais des valeurs qu'il est possible de combiner ensemble via l'opérateur |.

Il est possible de vérifier si une valeur existe ou non, grâce à Enum.IsDefined

Merci beaucoup pour la réponse.