bool sur Enum

Version imprimable

20/06/2016, 15h22
petitours

bool sur Enum
Bonjour

Dans une classe je crée une méthode ayant des paramètres booléens

Code:

public void MaMethode(bool Param1)

Afin de faciliter l'utilisation de la classe j'aimerais fournir à IntelliSense les choix possibles et clarifier la synthase finale.
C'est à dire permettre de faire

Code:

MaMethode(Machin.Actif);

plutôt que

Code:

MaMethode(Truee);

Pour ça j'aurai bien fait ceci
Code:

1 2 3 4 5 6 7 8 9 10 public enum Machin { Actif= true, Inactif } public void MaMethode(Machin Param1) { }
Mais le enum est apparemment forcément un int

Comment puis je faire ça autrement ?

merci par avance
20/06/2016, 15h35
Sehnsucht
Personnellement je suis plutôt partisan de l'interface publique la plus claire (et simple d'utilisation) possible du coup je préfère 2 méthodes plutôt qu'une avec un flag soit :
Code:

1 2 3 4 5 ActiveMachin () DesactiveMachin () // au lieu de AgitSurMachin(bool actif)
Surtout que rien n'empêche ces 2 méthodes de déléguer leur boulot à cette méthode qui prend un flag mais fait partie de l'interface privée de la classe.

Après si on reste sur le modèle établi ; je partirais plutôt sur un argument de type enum ; et c'est dans le corps de cette méthode qu'il y aurait un test ou un switch pour gérer les différents cas.
20/06/2016, 15h36
lead8209
Salut, pas moyen de faire autrement :
Code:

1 2 3 4 5 public enum Machin { Inactif = 0 Actif= 1, }
Mais franchement faire Enum sur 2 valeurs n'a pas vraiment de sens.
Un Enum te facilite la vie quand par exemple tu remontes un code d'erreur et que tu as 50 (en fait plus de 2 ;) valeurs possibles.

Fais plutôt une fonction comme cela :
Code:

1 2 public void MaMethode(bool pEstActif)
Enfin tout dépend de e que tu veux faire. Avec l'exemple donné voici ma réponse ;)
20/06/2016, 15h43
ReiKiss
Salut, si tu veux garder la structure de code que tu as donné, tu peux essayer cela :
Code:

1 2 3 4 5 public static class Machin { public const bool Actif = true; public const bool Inactif = false; }
et tu pourra utiliser :

Citation:

MaMethode(Machin.Actif);
20/06/2016, 15h51
petitours

Merci a tous et en particulier à ReiKiss

C'est exactement ça que je cherchais à faire
Le but étant que là où on fait appel à cette méthode on ait une syntaxe plus claire et plus intuitive sans aller regarder à quoi correspond true et false.

Merci
20/06/2016, 15h58
petitours

en fait non :-(

En premier ca me dit que les type static ne peuvent pas etre utilisés en paramètres, ok, je vire static...

Après, j'ai l'intelliSence qui me propose bien ce que je voulais pour l'appel de la méthode mais
après ça me dit que je ne peux pas convertir un bool en "Machin" :(

Moi ceci fonctionne correctement chez moi (même avec la class static d'ailleur)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
        private void button1_Click(object sender, EventArgs e)
        {
            test(Machin.Actif);     // "C'est vrai"
            test(Machin.Inactif);   // "C'est faux"
        }
 
        private void test(bool val)
        {
            if (val)
                MessageBox.Show("C'est vrai");
            else
                MessageBox.Show("C'est faux");
        }
 
        public struct Machin
        {
            public const bool Actif = true;
            public const bool Inactif = false;
        }

L'idée était de préciser à IntelliSence quel type est attendu

Code:

1
2
3
4
5
6
7
8
private void test(Machin val)
        {
            if (val)
                MessageBox.Show("C'est vrai");
            else
                MessageBox.Show("C'est faux");
        }

Ok alors on va déclarer la class différemment :

Code:

1
2
3
4
5
6
7
8
9
public class Machin
{
     private bool value;
     public static Machin Actif { get { return new Machin(true); } private set { } }
     public static Machin Inactif { get { return new Machin(false); } private set { } }
     private Machin() {}
     private Machin(bool v) {value = v;}
     public static implicit operator bool(Machin o) {return o.value;}
}

la fonction test :

Code:

1
2
3
4
5
6
7
private void test(Machin val)
{
    if (val)
        MessageBox.Show("C'est vrai");
    else
        MessageBox.Show("C'est faux");
}

et tu pourra appeler la fonction test comme ca :

Code:

test(Machin.Actif);

J'ai essayé, normalement ca marche même si c'est un peut tiré par les cheveux..

20/06/2016, 19h15
petitours

Outch !!

Merci, ça le fait... mais ça doit surement aussi me dire que je ne suis pas partis dans une bonne direction...:lol:

vive l'usine à gaz pour basiquement faire ce que je disais :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
enum Machin
{
    Inactif,
    Actif
}
 
public void Test (Machin val)
{
    switch (val)
    {
        case Machin.Inactif:
            MessageBox.Show ("c'est faux");
            break;
        case Machin.Actif:
            MessageBox.Show ("c'est vrai");
            break;
        default:
            throw ArgumentOutOfRangeException ("val", "unexpected value");
    }
}

Même si je préfère clairement :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void TestActif () // avec un nom significatif
{
    TestInternal (true);
}
 
public void TestInactif () // toujours avec un nom significatif
{
    TestInternal (false);
}
 
private void TestInternal (bool estActif) // potentiellement internal si besoin est
{
    if (estActif)
        MessageBox.Show ("c'est vrai");
    else
        MessageBox.Show ("c'est faux");
}

Après les goûts et les couleurs :D

20/06/2016, 23h20
petitours

Merci

J'ai clairement orienté mes préférences :mrgreen: