Discussion :

[lasrevinu]

Bonjour à tous,
Je voudrai créer une enumeration optionEnum qui contienne les strings
"option1", "option2", "option3", "option4"

seulement enum de C# n'est valable que pour des nombres.
quelqu'un aurait deja resolu ce probleme ?

merci

[Louis-Guillaume Morand]

pas du tout. une énum, c'est des valeurs, qui ont une clé de type int, mais ca reste des valeurs derrière, et à qui tu peux mettre l'attribut Description pour utiliser/afficher une chaine particulière
donc tu peux utiliser çà:

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
public enum HistoryStatus
    {
        [Description("New Demand")]
        NewDemandEmap = 1,
        [Description("Waiting for CF Validation")]
        WaitingForCFValidationEmap = 2,
        [Description("Waiting for Coordinator Validation")]
        WaitingForCoordinatorValidationEmap = 3,
        [Description("Waiting for CBC Validation")]
        WaitingForCBCValidationEmap = 4,
        [Description("Waiting for final validation")]
        WaitingForHabilitationConfirmationEmap = 5,
        [Description("Demand accepted")]
        HabilitationConfirmedEmap = 6,
    }

ca marche à merveille pour s'assurer pour avoir un affichage particulier, et des clés uniques, pour s'assurer de l'unicité de la chose


ou alors, tu utilises des classes static si c'est que pour ce l'affichage

Code :

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

1
2
3
4
5
6
7
8
public static class RolesNames
    {
        public const string STPCoordinator = "STP Coordinator";
        public const string FunctionnalCorrespondent = "CF";
        public const string CBC = "CBC";
        public const string Reader = "Reader";
        public const string MEEdoc = "ME E-doc";
    }

[Graffito]

tu peux mettre l'attribut Description pour utiliser/afficher une chaine particulière

Ce serait parfait si HistoryStatus.NewDemandEmap.ToString() donnait "New Demand" au lieu de "NewDemandEmap" ?
Est-ce le cas ?

[Louis-Guillaume Morand]

Ce serait parfait si HistoryStatus.NewDemandEmap.ToString() donnait "New Demand" au lieu de "NewDemandEmap" ?
Est-ce le cas ?

non le toString() ne te donne pas la valeur de l'attribut mais on peut le faire avec une petite méthode et de la réflexion

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
/// <summary>
        /// Converts the enum for binding.
        /// </summary>
        /// <param name="enumeration">The enumeration.</param>
        /// <returns></returns>
        public static List<EnumerationValue> ConvertEnumForBinding(Enum enumeration)
        {
            List<EnumerationValue> results = new List<EnumerationValue>();
 
            // Use reflection to see what values the enum provides
            MemberInfo[] members = enumeration.GetType().GetMembers();
            foreach (MemberInfo member in members)
            {
                // See if the member has a Description attribute:
                object[] descriptionAttributes = member.GetCustomAttributes(
                    typeof(DescriptionAttribute), true);
 
                if (descriptionAttributes.Length > 0)
                {
                    string description = ((DescriptionAttribute) descriptionAttributes[0]).Description;
                    string value = member.Name;
                    results.Add(new EnumerationValue(description, value));
                }
            }
 
            return results;
        }
 
        #region Nested type: EnumerationValue
 
        /// <summary>
        /// Allows to use enumerations in the designer for specific usercontrols
        /// </summary>
        public class EnumerationValue
        {
            private readonly string _displayText;
            private readonly object _value;
 
            /// <summary>
            /// Initializes a new instance of the <see cref="EnumerationValue"/> class.
            /// </summary>
            public EnumerationValue()
            {
            }
 
            /// <summary>
            /// Initializes a new instance of the <see cref="EnumerationValue"/> class.
            /// </summary>
            /// <param name="displayText">The display text.</param>
            /// <param name="value">The value.</param>
            public EnumerationValue(string displayText, object value)
            {
                _displayText = displayText;
                _value = value;
            }
 
            /// <summary>
            /// Gets the display text.
            /// </summary>
            /// <value>The display text.</value>
            public string DisplayText
            {
                get { return _displayText; }
            }
 
            /// <summary>
            /// Gets the value.
            /// </summary>
            /// <value>The value.</value>
            public object Value
            {
                get { return _value; }
            }
        }
 
        #endregion

Maintenant, ca peut même se faire évoluer pour taper dans des ressources afin de gérer la localisation, tout en gardant l'avantage des enums. (même si je l'accorde, ca fait beaucoup de bidouillage autour)

est ce une bonne idée de faire une enumeration ou une classe statique tout compte fait ?

ca dépend ce que tu veux faire. L'enuméation te servira surtout si tu veux récupérer les valeurs (nombres) pour insérer en base. si c'est pour binder sur une drop down, c'est aussi mieux, bien que la réflexion sur ta classe soit possible.

si c'est juste pour toi, t'aider dans le code, et limiter les valeurs possibles quand tu écris ton code alors la classe statique peut être plus simple à mettre en place (peut être mixé avec des constantes)

donc la réponse à ta question dépend de ce que tu veux faire

[alexadvance]

Et pourquoi pas simplement déclarer un type :

Code :

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

1
2
 
public enum optionEnum {option1, option2, option3};

Tu as besoin que ca s'écrive plus joliment ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public static String DisplayEnum(optionEnum val)
{
    switch(val)
    {
       case optionEnum.option1 : return "C'est l'option 1"; break;
       case optionEnum.option2 : return "C'est l'option 2"; break;
       case optionEnum.option3 : return "C'est l'option 3"; break;
       default : return "Option inconnu"; break;
     }
}
 
MessageBox.Show("Ma valeur est" + DisplayEnum(myval) );

Et pour faire plus "objet" tu peux créer une classe avec ton enum, et surcharger ta fonction ToString() qui fera la même chose que DisplayEnum();

[Louis-Guillaume Morand]

sauf que ton idée, ca veut dire qu'à chaque fois que tu édites ton énum, tu dois éditer ta méthode. Supposons que le cas se reproduise plein de fois dans le projet, ca veut dire que t'as autant de méthodes que d'objets, donc tu perds tout idée de généricité, et ta logique, elle est découplée en deux endroits (=moindre visibilité, possibilité de faire une erreur, si tu rénomme un champ de l'enum, tu dois corriger le switch, etc.), ton énum et le résultant (DisplayEnum).

cela parait donc plus simple mais dès la seconde utilisation de ce cas de figure ou dès la première modification du contexte (par exemple un équivalent en base ou autre), il faudra faire des modifs de code à plusieurs endroits et donc on y perd en totalement en productivité et donc la solution apparait de suite moins idéale

[lasrevinu]

Merci pour ta reponse,
les deux solutions ont l'air de bien fonctionner,

seulement je n'arrive pas à integrer mon enumeration dans les constructeurs de ma classe,

je voudrais avoir la chose suivante:

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
class machine
{
 
private SerialPort serialPort;
public enum optionEnum 
        {
            [Description("option1")]
            Ch1map = 1,
            [Description("option2")]
            Ch2map = 2,
            [Description("option3")]
            Ch3map = 3,
            [Description("option4")]
            Ch4map = 4,
        }
 
public machine()
        {
        }
        public machine(SerialPort Comm)
        {
            this.serialPort = Comm;
        }
 
        public machine(SerialPort Comm, optionEnum o1 )
        {
            this.serialPort = Comm;
            this.optionEnum = Ch1map;
        }
 
        public machine(SerialPort Comm, optionEnum o1, optionEnum o2  )
        {
            this.serialPort = Comm;
            this.optionEnum = Ch1map;
            this.optionEnum = Ch2map;
        }
        public machine(SerialPort Comm, optionEnum o1, optionEnum o2, optionEnum o3 )
        {
            this.serialPort = Comm;
            this.optionEnum = Ch1map;
            this.optionEnum = Ch2map;
            this.optionEnum = Ch3map;
        }
 
        public machine(SerialPort Comm, optionEnum o1, optionEnum o2, optionEnum o3, optionEnum o4  )
        {
            this.serialPort = Comm;
            this.optionEnum = Ch1map;
            this.optionEnum = Ch2map;
            this.optionEnum = Ch3map;
            this.optionEnum = Ch4map;
        }
}

est ce une bonne idée de faire une enumeration ou une classe statique tout compte fait ?
merci encore