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 ?

[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

[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

[alexadvance]

En effet, c'était le "pourquoi" de ma dernière phrase.

D'ailleurs, on pourrait pas faire avec un :

Code :

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

1
2
3
 
public static enum optionEnum {option1, option2, option3};
public Dictionnary<optionEnum ,String> MyEnumNames = new  Dictionnary<optionEnum ,String>();

Remarque ca résout toujours pas le problème de pouvoir en faire quelquechose de générique.

[realpasso]

Sinon, il y a aussi le tableau

Code :

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

1
2
3
4
5
6
7
8
9
10
enum Truc
{
none = 0,
bla,
ble,
bli
};
String labels[] = { "aucun", "super bla", "hyper ble", "mega bli"};
Truc monTruc;
labels[(int)monTruc];

Mais de toute façon dans quelques temps tu voudras mettre tout ça dans les ressources.

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

oui ! en même temps, s'il ajoute une valeur c'est qu'il y a une règle de gestion sinon ce sont des resources et il n'a même pas besoin d'enum. Et en bon dév on commence par modifier cette fonction pour pouvoir l'afficher (sinon on a pas besoin du libellé) et pouvoir tester notre belle implémentation du cas.

[lasrevinu]

Merci à tous
mon code devient le suivant:

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
class machine
{
 
private SerialPort serialPort;
private string option;
public enum optionEnum { option1, option2, option3, option4 };
 
public machine()
        {
        }
        public machine(SerialPort Comm)
        {
            this.serialPort = Comm;
        }
 
        public machine(SerialPort Comm, optionEnum o1 )
        {
            this.serialPort = Comm;
            this.option= optionEnum.option1.toString() ;
        }
 
        public machine(SerialPort Comm, optionEnum o1, optionEnum o2  )
        {
            this.serialPort = Comm;
            this.option= optionEnum.option1.toString() ;
            this.option= optionEnum.option2.toString() ;
        }
        public machine(SerialPort Comm, optionEnum o1, optionEnum o2, optionEnum o3 )
        {
            this.serialPort = Comm;
            this.option= optionEnum.option1.toString() ;
            this.option= optionEnum.option2.toString() ;
            this.option= optionEnum.option3.toString() ;
        }
 
        public machine(SerialPort Comm, optionEnum o1, optionEnum o2, optionEnum o3, optionEnum o4  )
        {
            this.serialPort = Comm;
            this.option= optionEnum.option1.toString() ;
            this.option= optionEnum.option2.toString() ;
            this.option= optionEnum.option3.toString() ;
            this.option= optionEnum.option4.toString() ;
        }
}

[lasrevinu]

Il y a une petite subtilité que je me permet de vous faire part:
lorsque je crée une nouvelle instance de ma classe machine:

Code :

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

Machine1 = new Machine(serialport1, machine.optionEnum.option1)

cela me va,
par contre:

Code :

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

Machine1 = new Machine(serialport1, machine.optionEnum.option1, machine.optionEnum.option1)

est possible à instancier,
j'aurai 2fois l'option 1 et cela ne me convient pas vraiment

Avez vous des suggestions?
J'espere que c'etait assez clair

merci pour votre aide

[Louis-Guillaume Morand]

pourquoi tu mets deux fois option1 si ca te convient pas? :p

sinon passe un seul deuxieme argument, un dictionnaire de paramètre par exemple. Et puis toi, tu le "nettoies" dans ton constructeur pour éviter les bêtises de celui qui utilise ta classe. et surtout cette solution permet de passer N arguments, si jamais t'as besoin de faire évoluer là chose.

[lasrevinu]

Merci pour ta reponse,
c'est nikel mnt !

[realpasso]

Il y a une petite subtilité que je me permet de vous faire part:
lorsque je crée une nouvelle instance de ma classe machine:

Code :

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

Machine1 = new Machine(serialport1, machine.optionEnum.option1)

cela me va,
par contre:

Code :

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

Machine1 = new Machine(serialport1, machine.optionEnum.option1, machine.optionEnum.option1)

est possible à instancier,
j'aurai 2fois l'option 1 et cela ne me convient pas vraiment

Avez vous des suggestions?
J'espere que c'etait assez clair

merci pour votre aide

flags si les valeurs le permettent

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
[flags]
enum Options
{
none = 0,
options1 = 1,
options2 = 2,
options3 = 4,
...
}
 
Machine(Options options)
{
if( (options1 & options) == options1)