Enumeration d'enumerations

Question

Bonjour à tous,

J'ai une classe qui comprend ces trois énumérations:
   privateenume1 { a 1, b 2 };    privateenume2 { c 1, d 2 };
    publicenumE { e1, e2};

Quelqu'un saurait-il comment faire pour obtenir l'enumération e1 lorsque je fais E.e1?
Sachant qu'il faut éviter de faire ça :

 switch monType
   "e1":
         monEnum = e1;
         break;
   "e2:
         monEnum = e2;
         break;

Je veux éviter d'avoir pleins de case à chaque fois que j'irai rajouter une énumération (ex: e3).

MERCI DE VOTRE AIDE

cs_MoH008 · Answer

Salut,
cela reviendrait plus au moins au même mais tu peux utiliser une list contenant tes types d'énumération  liste = {e1,e2...}. Quand tu crées une énum tu l'ajoutes dans la liste.
Au final, tu n'auras plus qu'à vérifier que le type existe dans ta liste, tu récupères le type et tu l'attribues à monEnum

LordOfTheShadow · Answer

Excuse moi pourrais-tu m'expliquer un peu plus stp...

La connaissance est la plus grande des richesses.

cs_coq · Answer

Bonjour, 

Effectivement, dans "public enum E { e1, e2 };", "e1" et "e2" ne font absolument pas références aux énumérations e1 et e2, ils s'agit juste de 2 valeurs Int32, 0 et 1.

A partir de ce constat, il va bien falloir faire le travail de correspondance à un moment donné.
Si tu nous expliquais le besoin qui te pousse à mettre en place ce genre de chose, qu'on voit où on va ou s'il n'y aurait pas une autre approche ?

Il y a bien une solution basée sur un attribut personnalisé mais s'il y a moyen de faire moins violent...
A tout hasard, un brouillon à finaliser : 

    [AttributeUsage(AttributeTargets.Field)]
    public class ETargetTypeAttribute : Attribute
    {
      public ETargetTypeAttribute(Type targetType)
      {
        this._targetType = targetType;
      }


      private Type _targetType;


      public Type TargetType
      {
        get
        {
          return this._targetType;
        }
      }
    }


    private enum e1 { a 1, b 2 };    private enum e2 { c 1, d 2 };
    public enum E
    {
      [ETargetType(typeof(e1))]
      e1,


      [ETargetType(typeof(e2))]
      e2
    };


    private static Type TranslateEValueToEnumType(E value)
    {
      Type targetType = null;


      FieldInfo fieldInfo = typeof(E).GetField(value.ToString());


      ETargetTypeAttribute[] attributes = (ETargetTypeAttribute[])fieldInfo.GetCustomAttributes(typeof(ETargetTypeAttribute), false);


      if (attributes != null && attributes.Length > 0)
      {
        targetType = attributes[0].TargetType;
      }


      return targetType;
    }

/*
coq
MVP Visual C#
CoqBlog
*/

LordOfTheShadow · Answer

Bonjour coq,
Désolé de répondre aussi tard c'est parce que je travaille pas tout le temps. Donc voila un peu plus d'explications:



J'ai une solution qui contient pleins d'énumérations (J'ai changé les noms car c'est secret professionnel désolé) dont:



[FlagsAttribute]publicenumfamille { L 1, P 2, D = 4};








public



enum


enum_l
 { A = 1, B, C};
publicenumenum_p { Toto = 1, Titi, Tata};
publicenumenum_d { rouge = 1, vert, bleu};





J'ai également une deuxième solution que j'ai appelé Utiles et qui contient la fonction ci-dessous qui me permet de récupérer le string d'un item d'une énumération:







public






static





string

 Obtenir_String_Enum(


Type

 p_type, 


int



 p_val)
{



   return





Enum



.GetName(p_type, p_val);
}

Et enfin j'ai une troisième solution intégrant évidemment les deux dll des deux premières solutions et qui va les utiliser comme ci-dessous dans une de ses procédures:











private





void

 Remplir(int
 num_famille
)
{


   Type

 monType; 


//Contiendra le type de famille






   string

 famille= 

Utiles

.Obtenir_String_Enum(

typeof

(

famille

), num_famille

);









   string


 id = 


""



;







//Suivant la famille:



switch

 (famille)
{



   case





"L"

:
      monType = 


typeof

(


enum_l

);







      id = 


Utiles

.Obtenir_String_Enum(monType, val_id

);



      break

;



   case





"P"

:
      monType = 


typeof

(


enum_p

);







      id = 


Utiles

.Obtenir_String_Enum(monType, val_

id);



      break

;



   case





"D"

:
      monType = 


typeof

(


enum_d

);







      id = 


Utiles

.Obtenir_String_Enum(monType, val_

id);



   break

;




}





Voila actuellement comment je fais. Le gros soucis c'est que je suis obligé de rajouter un case à mon suivant chaque fois que je rajoute une famille et son énumération. Je voudrai éviter donc de faire un switch. Merci de l'aide, je patoge bien...

cs_coq · Answer

Bonjour, 

Je ne suis pas certains d'avoir bien saisi, mais tu peux obtenir l'instance de type représentant un type à partir de son nom via des méthode du genre Assembly.GetType.

/*
coq
MVP Visual C#
CoqBlog
*/

Enumeration d'enumerations

5 réponses

Votre réponse

Discussions similaires