Discussion :

[Neitsa]

Bonjour à tous,

Je cherche un moyen de mimer le comportement d'une sous-énumération en C#, ou plus exactement d'une énumération hiérarchique.

Pour exposer simplement le problème, imaginons que j'ai une enum comme ceci :

Code :

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

1
2
3
4
5
6
 
public enum fooEnum : int
{
     fooA,
     fooB,
}

Maintenant j'aimerais ajouter une (ou des) contrainte(s) supplémentaire(s) :

fooA ne peut être composé que de : fooA1 et fooA2, tandis que fooB ne peut être composé que de fooBx et fooBy. (toutes ces sous-valeurs étant entières elles aussi).

Dans une méthode quelconque, je pourrais tester les "sous-valeurs" de fooA et fooB comme ceci :

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
 
if (valueTest == fooEnum.fooA.fooA1)
// ...
 
//autre possibilité de test
switch(valueTest2)
{
     case fooEnum.fooB.fooBx:
      // ...
     break;
 
     case fooEnum.fooB.fooBy:
      // ...
     break;
 
     default:
       //...
     break;
}

Le problème c'est que ne sais absolument pas comment modéliser cela simplement, c-a-d sans un système (assez) "lourd" à base d'héritage et de valeurs entières constantes (sachant que je ne ferais rien d'autre avec ces valeurs que les tester).

Est-ce la seule option, ou existe-il une autre possibilité ?

Je vous remercie

[BCmDev]

Pourquoi ne pas simplement utiliser un namespace ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
namespace XXX.fooEnum
{
    public enum fooA
    {
        fooA1,
        fooA2
    }
    public enum fooB
    {
        fooB1,
        fooB2
    }
}