Discussion :

[Oberown]

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.

[tomlev]

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

Code :

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

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 :

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

1
2
3
4
5
6
7
using Developpez.Dotnet;
 
...
 
MyEnum x = MyEnum.Toto;
...
string description = x.GetDescription();

[Oberown]

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 ?

[tomlev]

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

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 :

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

[Bluedeep]

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

[Oberown]

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

[Bluedeep]

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

Exemple :

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

[Oberown]

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

Code c# :

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
 
 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 ?

[BenoitM]

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

[Oberown]

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

[BenoitM]

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

[Bluedeep]

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 ?

[Oberown]

En gros il faudrait que je fasse ainsi:

Code C# :

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
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
            }
        }
    }

[tomlev]

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 :

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
    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 :

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

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

[Bluedeep]

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.

[Oberown]

Que faire alors ?

[Bluedeep]

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.

[Oberown]

Merci

[BenoitM]

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 )

[tomlev]

Aucun doute sur le fait que cela marche.

Effectivement, c'est testé et ça 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.

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 :

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

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