Propriété lié à une enum

Salut
J'ai une énumération.
Je souhaiterais lié des strings pour type de mon enum.

Comment faire ?
- Dois-je crée une fonction de mon enum retourne un objet qui a des propriétés qui se remplissent en fonction de mon enum ?

- Un système d'attribut ?

- Autre ?

Merci.

Pour associer une chaine à chaque valeur de l'enum, tu peux utiliser l'attribut Description :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

using System.ComponentModel; ...   public enum MyEnum { [Description("Description de Titi")] Titi, [Description("Description de Tata")] Tata, [Description("Description de Toto")] Toto }

---

Pour récupérer l'attribut facilement, tu peux utiliser la méthode d'extension GetDescription qui est dans la lib Dvp.NET :

Code:

---

1 2 3 4 5 6 7

using Developpez.Dotnet;   ...   MyEnum x = MyEnum.Toto; ... string description = x.GetDescription();

---

J ai besoin de deux string. Et je pense par la suite mettre un bool.
Dois-je modifier la librairie pour avoir ce que je veux ?

Citation:

---

Envoyé par Oberown

J ai besoin de deux string. Et je pense par la suite mettre un bool.

---

Dans ce cas, crée un attribut avec toutes les infos que tu veux

Citation:

---

Envoyé par Oberown

Dois-je modifier la librairie pour avoir ce que je veux ?

---

Non, crée plutôt une méthode extension spécifique. En gros ça va donner un truc comme ça (en supposant que ton attribut s'appelle MyAttribute)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public static MyAttribute GetMyAttribute(this Enum value) { Type type = value.GetType(); string name = Enum.GetName(type, value); if (name != null) { FieldInfo field = type.GetField(name); if (field != null) { MyAttribute attr = Attribute.GetCustomAttribute(field, typeof(MyAttribute)) as MyAttribute; if (attr != null) return attr; } } return null; }

---

Je n'avais jamais pensé que Enum pouvait être utilisé comme classe de base d'un enum; honte à moi :cry:

Est-il possible dans mon attribut de mettre en paramètre des constantes ou des variables ?

Citation:

---

Envoyé par Oberown

Est-il possible dans mon attribut de mettre en paramètre des constantes ou des variables ?

---

Exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

enum enumX { [MyAttributeToEnum(1, "desc 1")] valeur_a, [MyAttributeToEnum(2, "desc 2")] valeur_b, [MyAttributeToEnum(3, "desc 3")] valeur_c };   [AttributeUsage(AttributeTargets.Field)] public class MyAttributeToEnum : Attribute { public readonly int UneValeur; public readonly string UneChaine; public MyAttributeToEnum(int valeur, string chaine) { UneValeur = valeur; UneChaine = chaine; } }

---

Par contre, j'ignore ce que tu veux dire par mettre des variables en paramètres.

Ce n'est pas vraiment ça que j'ai demandé.
Plutôt:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public class Divers { public const int toto = 5; }     enum enumX { [MyAttributeToEnum(toto, "desc 1")] valeur_a, [MyAttributeToEnum(2, "desc 2")] valeur_b, [MyAttributeToEnum(3, "desc 3")] valeur_c };

---

Si toto n'est plus une constante je ne peux pas compiler.
Par exemple, avec un fichier de configuration je dois être capable de mettre d'autres traductions dans mes strings.

Comment faire ?

Je ne pense pas qu'il soit logique de mettre les traductions dans l'enum
Pour moi la traduction d'un enum est une classe a part.


cf cette classe pourrait aller rechercher la traduction dans une base de donnée, un fichier ressources, ect

En plus imagine que demain on te demande de supporter une nouvelle langue, tu dois aller changer ton code source :roll:

Donc il faudrait une class qui regarde pour chaque enum sa traduction ?

Pour moi oui, [Description("Description de Titi")] c'est très pratique pour aller vite et quand tu n'as qu'une langue à gérer mais ce n'est pas "pro"

et hardcoder l'affichage c'est mal ;)
Imagine que tu aies fais une faute d'orthographe...

Citation:

---

Envoyé par Oberown

Ce n'est pas vraiment ça que j'ai demandé.
....
Si toto n'est plus une constante je ne peux pas compiler.

---

Je pense que tu n'as pas compris le cycle de vie des instances des classes Attribute.

L'instanciation des Attributes n'est pas lié à l'instanciation de la classe qui les référence comme métadonnées.

Les Attributes sont instanciés uniquement lorsqu'il sont demandés par un GetCustomAttribute, via la Reflection.

Le fait que la classe qui les contient ait été ou non instanciée ne rentre pas en ligne de compte.

Par voie de conséquence, on ne peuit bien entendu pas utiliser un membre de classe comme paramètre au constructeur de l'Attribute : cela n'aurait aucun sens.

Imagine que tu ais deux instances ou plus de ta classe - situation plutôt normale sauf pour les singleton : quelle valeur de membre de quelle instance doit être utilisée pour la classe Attribute ?

En gros il faudrait que je fasse ainsi:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

public enum MyEnum { Voiture, Maison, Bateau }   public class InfoMyEnum { public string Title { get; private set; } public string Champs2 { get; private set; } public int myInt { get; private set; }   public InfoMyEnum(MyEnum m) { switch (m) { //selon mon enum je met à jour les champs } } }

---

Effectivement les paramètres des attributs doivent être des constantes...

Il y a une solution qui consiste à passer en paramètre non pas le texte de la description, mais plutôt les éléments qui permettent de trouver la description lors de l'exécution. Par exemple, en utilisant le système de ressources localisées :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

public class LocalizedDescriptionAttribute : DescriptionAttribute { private readonly string _resourceKey; private readonly ResourceManager _resourceManager;   public LocalizedDescriptionAttribute(string resourceKey, Type resourceType) { _resourceKey = resourceKey; _resourceManager = new ResourceManager(resourceType); }   public override string Description { get { return _resourceManager.GetString(_resourceKey); } } }

---

Ensuite il suffit d'utiliser LocalizedDescriptionAttribute à la place de DescriptionAttribute, et ça marche ;)

Code:

---

1 2 3 4 5 6 7 8 9

public enum MyEnum { [LocalizedDescription("TitiDesc", typeof(Properties.Resources))] Titi, [LocalizedDescription("TataDesc", typeof(Properties.Resources))] Tata, [LocalizedDescription("TotoDesc", typeof(Properties.Resources))] Toto }

---

(ça suppose bien sûr d'avoir défini les ressources TitiDesc, TataDesc et TotoDesc ...)

Citation:

---

Envoyé par tomlev

Il y a une solution qui consiste à passer en paramètre non pas le texte de la description, mais plutôt les éléments qui permettent de trouver la description lors de l'exécution. Par exemple, en utilisant le système de ressources localisées

---

Aucun doute sur le fait que cela marche.

Après on peut s'interroger sur le fait que des métadonnées de classes soient contextuelles (au sens large).
Je ne suis pas sur que ce soit une bonne idée, du point de vue de l'architecture applicative.

Que faire alors ?

Citation:

---

Envoyé par Oberown

Que faire alors ?

---

Ben utilise la solution de tomlev, techniquement elle est parfaite.

Mais je ne suis pas trop favorable au fait que un attribut ait une dépendance contextuelle.

Dans tous les cas, si tu utilises sa solution, "blinde" le code de la classe attribut avec des try/catch, de telle sorte que l'utilisation de la reflection sur ta classe ne puisse pas planter en l'absence des resources demandées.

Merci :)

1) Faire une classe Translator par enum le plus complexe mais le plus souple (exemple lire les traductions dans une base de données mais plus lourd en resources et mais les traductions sont centraliser)
2) Utiliser la solution de tomlev (si tu dois changer une traduction tu devras redistribuer le fichier Resource à tous les utilisateurs mais c'est nettement moins lourd et grave que de devoir changer le code et logiquement on ne s'amuse pas souvent à changer les traductions )

Citation:

---

Envoyé par Bluedeep

Aucun doute sur le fait que cela marche.

---

Effectivement, c'est testé et ça marche ;)

Citation:

---

Envoyé par Bluedeep

Après on peut s'interroger sur le fait que des métadonnées de classes soient contextuelles (au sens large).
Je ne suis pas sur que ce soit une bonne idée, du point de vue de l'architecture applicative.

---

Je ne vois pas trop ce que tu veux dire par là... qu'entends tu par "métadonnées contextuelles" ? Tu vois des problèmes potentiels avec cette approche ?

Une technique similaire est utilisée dans la classe DisplayAttribute du framework :

Code:

---

1 2	[Display(Name = "TotoDisplay", ResourceType = typeof(Properties.Resources))] public string Toto { get; set; }

---

Citation:

---

Envoyé par Bluedeep

Dans tous les cas, si tu utilises sa solution, "blinde" le code de la classe attribut avec des try/catch, de telle sorte que l'utilisation de la reflection sur ta classe ne puisse pas planter en l'absence des resources demandées.

---

Ca ne plantera pas, GetString renverra null si la ressource n'existe pas. Et si c'est la création du ResourceManager échoue, c'est que le fichier de ressources n'existe pas, et c'est donc un problème qui sera détecté immédiatement lors du développement ; à moins de ne pas avoir testé le code du tout, ça n'arrivera pas en production.