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
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;
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...
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.