Paramètres Enum [Flags]

Version imprimable

27/06/2016, 09h38
Aidenam

Paramètres Enum [Flags]

Bonjour,

Je suis en train de développer une bibliothèque de classe dans laquelle des méthodes pourront être appelées en précisant des paramètres. Ceux-ci doivent être une combinaison d'options parmi une grande quantité de possibilités. J'ai donc tout naturellement choisi d'implémenter ceci en tant qu'énumération de type Flags. Mais Le nombre d'options possibles dépasse la capacité d'un enum (64 je crois). Je ne peux pas scinder ces paramètres en plusieurs listes différentes.

Je souhaitais vraiment utiliser les énumérations afin que l'utilisateur de la librairie puisse être guidé par l'intellisense de VS lors de l'écriture du code d'appel de ces méthodes. Je ne vois pas bien comment trouver une alternative aussi efficace.

Je suis ouvert à toute suggestion. D'avance merci.
27/06/2016, 10h10
theMonz31

bonjour

un enum est un int donc, on peut aller jusqu'à la valeur maximale de l'enum et par conséquent, avoir le même type de combinaison que quand on fait du binaire :)
27/06/2016, 10h50
Aidenam

Oui, ça je le sais. On peut aller jusqu'à 32 ou même 64 bits. Mais comment proposer davantage de combinaisons lors de l'appel à une méthode ?
27/06/2016, 11h13
theMonz31

en passant une liste ou un tableau contenant la liste des options :)
27/06/2016, 11h25
Aidenam

Sauf que ça ne répond aucunement à mon besoin : guider l'utilisateur de la méthode en lui proposant une liste d'options prédéfinies, ce que permet l'énumération, avec en plus l'aide de l'Intellisense.

J'ai bien l'impression que la seule solution technique serait de scinder les options en plusieurs groupes et d'imposer le passage de plusieurs paramètres à la méthode, mais dans mon cas c'est très difficile.
27/06/2016, 11h29
theMonz31

et si tu montrais ce que tu voulais faire avec un bout de code, je pense que ça serait un peu moins nébuleux, parce que là, j'ai beau cherché à comprendre,
je ne trouve pas l'énoncé du problème clair...

Mets un bout de code de ce que tu aimerais proposer à l'utilisateur ?

Je ne vois pas ce qu'il y a de "nébuleux" :

Pour donner un exemple clair je suis en train de créer une API pour encapsuler les accès à WMI.

D'un côté une énumération pour gérer les propriétés de la classe W32_ComputerSystem :
Code:

1 2 3 4 5 6 7 8 9 10 11 [Flags] public enum ComputerSystemProperties { AdminPasswordStatus = 1, AutomaticManagedPagefile = 2, AutomaticResetBootOption = 4, AutomaticResetCapability = 8, BootOptionOnLimit = 16, ... }
De l'autre côté un constructeur de classe utilisant cette énumération :
Code:

1 2 3 4 5 6 7 8 public class WmiComputerSystem : WmiObject { public WmiComputerSystem(ComputerSystemProperties properties) { ... } }
Ce code ne peut fonctionner, l'énumération ayant environ 70 valeurs dans ce cas (les valeurs correspondant aux propriétés de la classe W32_ComputerSystem plus quelques options que je rajoute).

27/06/2016, 11h50
Pol63

pourquoi pas une classe avec une propriété par option (de type booléen ou pas du coup)
et la méthode demande une instance de cette classe en paramètre
27/06/2016, 11h57
Aidenam

Citation:

Envoyé par Pol63

pourquoi pas une classe avec une propriété par option (de type booléen ou pas du coup)
et la méthode demande une instance de cette classe en paramètre

J'ai effectivement pensé à cette solution. Ça me parait un peu lourd à gérer (il me faudra de nombreuses classes dédiées pour chaque objet WMI, uniquement pour ces passages de paramètres). Et surtout pour l'utilisateur c'est beaucoup moins pratique (nécessité d'instancier l'objet, de définir toutes les propriétés désirées pour enfin passer l'objet aux méthodes et constructeurs désirés). Sans parler du fait qu'il faudra gérer les valeurs par défaut des propriétés (nécessité sans doute d'utiliser des nullable<>)...

Mais actuellement je ne vois que cette solution ou le fait de scinder les paramètres.
27/06/2016, 12h03
ZenZiTone

Bonjour,

A ce que je vois dans le code que tu nous proposes, tu ne passes qu'une propriété au constructeur?

Autrement, pour pallier au problème de l'énumération tu peux faire une classe statique contenant toutes les propriétés sous forme de constantes, non?
27/06/2016, 12h12
Pol63

en vb.net il est possible de préciser via un attribut qu'on veut qu'un type à l'intellisense affiche des propriétés statiques d'une classe
c'est le cas par exemple pour la system.drawing.color, quand un paramètre est de type color, l'intellisense propose toutes les propriétés statiques de la classes Colors (qui sont donc des instances)
à voir si c'est possible en c#, auquel cas tu pourrais demander un paramarray de ce type, et donc tu pourrais mettre tous tes paramètres séparés par des virgules avec de l'intellisense

Citation:

Envoyé par ZenZiTone

Bonjour,

A ce que je vois dans le code que tu nous proposes, tu ne passes qu'une propriété au constructeur?

Autrement, pour pallier au problème de l'énumération tu peux faire une classe statique contenant toutes les propriétés sous forme de constantes, non?

Justement non. L'objectif est de passer une combinaison de propriétés au constructeur. D'où l'intérêt de l'énumération de type Flags.

Sinon l'idée de la classe statique m'intéresse, je n'y avais pas pensé. Du coup si je comprend bien ton idée l'utilisateur devrait appeler le constructeur ainsi :
Code:

1 2 3 4 5 6 7 8 public class WmiComputerSystem : WmiObject { public WmiComputerSystem(StaticClass.Constante1 | StaticClass.Constante13 | StaticClass.Constante24 | StaticClass.Constante35 ...) { ... } }
J'ai bon ou j'ai bon ?

Pour ma part si tu as trop de paramètres à transmettre et afin d'utiliser le plein potentiel de stockage de enum, je demanderai un paramètre de type tableau de ton enum.
Ça permet aussi de conserver une intellisense dans la construction du paramètre.
Exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public enum ComputerSystemProperties
{
    AdminPasswordStatus = 1,
    AutomaticManagedPagefile = 2,
    AutomaticResetBootOption = 3,
    AutomaticResetCapability = 4,
    BootOptionOnLimit = 5,
}
 
public void WmiComputerSystem(ComputerSystemProperties[] properties)
{
    if (properties.Contains(ComputerSystemProperties.AdminPasswordStatus))
        MessageBox.Show("AdminPasswordStatus");
    if (properties.Contains(ComputerSystemProperties.AutomaticManagedPagefile))
        MessageBox.Show("AutomaticManagedPagefile");
    if (properties.Contains(ComputerSystemProperties.AutomaticResetCapability))
        MessageBox.Show("AutomaticResetCapability");
}
 
private void button1_Click(object sender, EventArgs e)
{
    WmiComputerSystem(new ComputerSystemProperties[] { ComputerSystemProperties.AdminPasswordStatus, ComputerSystemProperties.AutomaticResetCapability } );
}

27/06/2016, 16h50
Invité

bonjour,

params ne correspondrait-il pas à ce que tu veux faire ?

ben

Salut !

Tu peux aussi faire comme ceci :
Avantage : si tu dois stocker un état, tu ne stocke qu'une seule valeur.
Je n'ai pas codé toutes les méthodes, comme le retrait d'une action par exemple, j'ai fait ça sur l'instant.

A savoir : Pour les opérations sur les bits, tu peux utiliser les int et les long. (selon ce que j'ai compris de la doc.)

Code:

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
77
78
79
using System;
 
namespace ConsoleApplication12
{
    public enum enActionsPossibles
    {
        Action1 = 1,
        Action2 = 2,
        Action3 = 4,
        Action4 = 8,
        Action5 = 16,
        Action6 = 32,
        Action7 = 64,
        Action8 = 128,
        Action9 = 256,
        Action10 = 512,
        Action11 = 1024,
        Action12 = 2048,
        Action13 = 4096,
        Action14 = 8192
    }
 
 
    class Program
    {
        static void SetActions(ref int listeActions, enActionsPossibles[] actions)
        {
            listeActions = 0;
            foreach (enActionsPossibles action in actions)
            {
                listeActions += (int)action;
            }
        }
 
 
        static void AddAction(ref int listeAction, enActionsPossibles action)
        {
            if (GetAction(listeAction, action)) return;
            listeAction += (int)action;
        }
 
 
        static bool GetAction(int listeAction, enActionsPossibles action)
        {
            return ((listeAction & (int)action) == (int)action);
        }
 
 
        static void Main(string[] args)
        {
            int ActionEnCours = 0;
            AddAction(ref ActionEnCours, enActionsPossibles.Action3);
            AddAction(ref ActionEnCours, enActionsPossibles.Action7);
            AddAction(ref ActionEnCours, enActionsPossibles.Action12);
 
 
            Console.WriteLine("Après les AddActions...");
            Console.WriteLine("Valeur de ActionsEnCours : {0}", ActionEnCours);
            Console.WriteLine("Action 1 dans la liste ? : {0}", GetAction(ActionEnCours, enActionsPossibles.Action1));
            Console.WriteLine("Action 3 dans la liste ? : {0}", GetAction(ActionEnCours, enActionsPossibles.Action3));
            Console.WriteLine("Action 7 dans la liste ? : {0}", GetAction(ActionEnCours, enActionsPossibles.Action7));
            Console.WriteLine("Action 11 dans la liste ? : {0}", GetAction(ActionEnCours, enActionsPossibles.Action11));
 
 
            SetActions(ref ActionEnCours, new enActionsPossibles[] { enActionsPossibles.Action1, enActionsPossibles.Action7, enActionsPossibles.Action11 });
 
 
            Console.WriteLine("Après SetActions...");
            Console.WriteLine("Valeur de ActionsEnCours : {0}", ActionEnCours);
            Console.WriteLine("Action 1 dans la liste ? : {0}", GetAction(ActionEnCours, enActionsPossibles.Action1));
            Console.WriteLine("Action 3 dans la liste ? : {0}", GetAction(ActionEnCours, enActionsPossibles.Action3));
            Console.WriteLine("Action 7 dans la liste ? : {0}", GetAction(ActionEnCours, enActionsPossibles.Action7));
            Console.WriteLine("Action 11 dans la liste ? : {0}", GetAction(ActionEnCours, enActionsPossibles.Action11));
 
 
            Console.ReadKey();
        }
    }
}

Citation:

Envoyé par Aidenam

Justement non. L'objectif est de passer une combinaison de propriétés au constructeur. D'où l'intérêt de l'énumération de type Flags.

Effectivement, je ne connaissais pas cette possibilité, intéressant !
Citation:
Envoyé par Aidenam
Sinon l'idée de la classe statique m'intéresse, je n'y avais pas pensé. Du coup si je comprend bien ton idée l'utilisateur devrait appeler le constructeur ainsi :
Code:

1 2 3 4 5 6 7 8 public class WmiComputerSystem : WmiObject { public WmiComputerSystem(StaticClass.Constante1 | StaticClass.Constante13 | StaticClass.Constante24 | StaticClass.Constante35 ...) { ... } }
J'ai bon ou j'ai bon ?
Du coup tu ne pourras pas utiliser les mêmes opérateur qu'avec un enum flags. Il te faudra passer un tableau ou une liste de cette classe.

Citation:
Envoyé par ericlm128
Pour ma part si tu as trop de paramètres à transmettre et afin d'utiliser le plein potentiel de stockage de enum, je demanderai un paramètre de type tableau de ton enum.
Ça permet aussi de conserver une intellisense dans la construction du paramètre.
Exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 public enum ComputerSystemProperties { AdminPasswordStatus = 1, AutomaticManagedPagefile = 2, AutomaticResetBootOption = 3, AutomaticResetCapability = 4, BootOptionOnLimit = 5, } public void WmiComputerSystem(ComputerSystemProperties[] properties) { if (properties.Contains(ComputerSystemProperties.AdminPasswordStatus)) MessageBox.Show("AdminPasswordStatus"); if (properties.Contains(ComputerSystemProperties.AutomaticManagedPagefile)) MessageBox.Show("AutomaticManagedPagefile"); if (properties.Contains(ComputerSystemProperties.AutomaticResetCapability)) MessageBox.Show("AutomaticResetCapability"); } private void button1_Click(object sender, EventArgs e) { WmiComputerSystem(new ComputerSystemProperties[] { ComputerSystemProperties.AdminPasswordStatus, ComputerSystemProperties.AutomaticResetCapability } ); }
Merci de toutes vos réponses. Celle de ericlm128 me parait la plus adaptée à ce que je veux faire. Ça implique une mécanique interne un peu lourde mais au moins ça reste agréable à utiliser pour l'utilisateur de la librairie. Je vais essayer ça. Merci encore à vous.