IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

C# Discussion :

Paramètres Enum [Flags]


Sujet :

C#

  1. #1
    Membre habitué
    Profil pro
    Inscrit en
    Mai 2009
    Messages
    10
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2009
    Messages : 10
    Par défaut 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.

  2. #2
    Expert confirmé

    Homme Profil pro
    Chef de projet NTIC
    Inscrit en
    Septembre 2006
    Messages
    3 580
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Chef de projet NTIC
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Septembre 2006
    Messages : 3 580
    Par défaut
    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

  3. #3
    Membre habitué
    Profil pro
    Inscrit en
    Mai 2009
    Messages
    10
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2009
    Messages : 10
    Par défaut
    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 ?

  4. #4
    Expert confirmé

    Homme Profil pro
    Chef de projet NTIC
    Inscrit en
    Septembre 2006
    Messages
    3 580
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Chef de projet NTIC
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Septembre 2006
    Messages : 3 580
    Par défaut
    en passant une liste ou un tableau contenant la liste des options

  5. #5
    Membre habitué
    Profil pro
    Inscrit en
    Mai 2009
    Messages
    10
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2009
    Messages : 10
    Par défaut
    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.

  6. #6
    Expert confirmé

    Homme Profil pro
    Chef de projet NTIC
    Inscrit en
    Septembre 2006
    Messages
    3 580
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : Chef de projet NTIC
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Septembre 2006
    Messages : 3 580
    Par défaut
    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 ?

  7. #7
    Membre habitué
    Profil pro
    Inscrit en
    Mai 2009
    Messages
    10
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2009
    Messages : 10
    Par défaut
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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).

  8. #8
    Expert éminent Avatar de Pol63
    Homme Profil pro
    .NET / SQL SERVER
    Inscrit en
    Avril 2007
    Messages
    14 204
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Puy de Dôme (Auvergne)

    Informations professionnelles :
    Activité : .NET / SQL SERVER

    Informations forums :
    Inscription : Avril 2007
    Messages : 14 204
    Par défaut
    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
    Cours complets, tutos et autres FAQ ici : C# - VB.NET

  9. #9
    Membre habitué
    Profil pro
    Inscrit en
    Mai 2009
    Messages
    10
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2009
    Messages : 10
    Par défaut
    Citation Envoyé par Pol63 Voir le message
    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.

  10. #10
    Membre Expert
    Homme Profil pro
    Développeur .NET
    Inscrit en
    Octobre 2013
    Messages
    1 563
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur .NET
    Secteur : Industrie

    Informations forums :
    Inscription : Octobre 2013
    Messages : 1 563
    Par défaut
    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?

  11. #11
    Expert éminent Avatar de Pol63
    Homme Profil pro
    .NET / SQL SERVER
    Inscrit en
    Avril 2007
    Messages
    14 204
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 43
    Localisation : France, Puy de Dôme (Auvergne)

    Informations professionnelles :
    Activité : .NET / SQL SERVER

    Informations forums :
    Inscription : Avril 2007
    Messages : 14 204
    Par défaut
    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
    Cours complets, tutos et autres FAQ ici : C# - VB.NET

  12. #12
    Membre habitué
    Profil pro
    Inscrit en
    Mai 2009
    Messages
    10
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2009
    Messages : 10
    Par défaut
    Citation Envoyé par ZenZiTone Voir le message
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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 ?

  13. #13
    Expert confirmé

    Homme Profil pro
    Responsable déploiement (SCCM, InTune, GPO)
    Inscrit en
    Juillet 2014
    Messages
    3 218
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 46
    Localisation : France, Seine Saint Denis (Île de France)

    Informations professionnelles :
    Activité : Responsable déploiement (SCCM, InTune, GPO)
    Secteur : Transports

    Informations forums :
    Inscription : Juillet 2014
    Messages : 3 218
    Par défaut
    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 : 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
    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 } );
    }

  14. #14
    Invité
    Invité(e)
    Par défaut
    bonjour,

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

    ben

  15. #15
    Membre éclairé
    Homme Profil pro
    Consultant informatique
    Inscrit en
    Juin 2007
    Messages
    72
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Consultant informatique
    Secteur : Industrie

    Informations forums :
    Inscription : Juin 2007
    Messages : 72
    Par défaut
    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 : 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
    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();
            }
        }
    }

  16. #16
    Membre Expert
    Homme Profil pro
    Développeur .NET
    Inscrit en
    Octobre 2013
    Messages
    1 563
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Développeur .NET
    Secteur : Industrie

    Informations forums :
    Inscription : Octobre 2013
    Messages : 1 563
    Par défaut
    Citation Envoyé par Aidenam Voir le message
    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 Voir le message
    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 : Sélectionner tout - Visualiser dans une fenêtre à part
    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.

  17. #17
    Membre habitué
    Profil pro
    Inscrit en
    Mai 2009
    Messages
    10
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2009
    Messages : 10
    Par défaut
    Citation Envoyé par ericlm128 Voir le message
    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 : 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
    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.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. IQueryAble -> Enum -> Paramètres de fonction
    Par Icewall dans le forum VB.NET
    Réponses: 4
    Dernier message: 23/11/2010, 09h52
  2. Binding avec un Enum en fonction de l'attribut Flag
    Par Chekov dans le forum Windows Presentation Foundation
    Réponses: 8
    Dernier message: 02/10/2009, 12h11
  3. Enum Type dans paramètres de Sub
    Par Domi2 dans le forum VBA Access
    Réponses: 7
    Dernier message: 05/03/2008, 09h56
  4. Paramètre 'Flags' de Invoke() non reconnu.
    Par Sunchaser dans le forum Langage
    Réponses: 2
    Dernier message: 11/02/2008, 23h49
  5. [java 5]utiliser un type enum en paramètres
    Par MicroPuce dans le forum Langage
    Réponses: 3
    Dernier message: 15/03/2007, 11h52

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo