Discussion :

[Marmounet]

Bonjour,
J'ai une question très simple mais je n'arrive pas à la résoudre.
Dans un module de constantes, j'ai créer la liste 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
 
Enum ListeProduits
    Rien = 0
    Pomme = 1
    Poire = 2
    Abricot = 3
    Cerise = 4
    Tulipe= 5
    Courgette = 6
    Pomme_De_Terre = 7
    Rose = 8
    Radis = 9
    Fruits = Pomme Or Poire Or Abricot Or Cerise
    Fleurs = Rose or Tulipe
    Légume = Courgette Or  Pomme_De_Terre Or Radis 
  End Enum

Dans mon module de code si l'utilisateur tape une valeur, je souhaite afficher la nature du produit

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
Dim ValeurDemandée as integer
ValeurDemandée=5
if ValeurDemandée= Fruit then 
   Affiche("Fruit")
elseif ValeurDemandée= Fleur then
   Affiche("Fleur")
elseif ValeurDemandée= Légume then
   Affiche("Légume")
else
   Affiche("Rien")
end if

Et c'est là que se pose le problème. Ce test ne fonctionne pas.
Question subsidiaire : Comment éviter la suite de ElseIf avec une routine qui renvoie directement le nom de la constante
Merci par avance

[m4k-Hurrican]

Bonjour,

Pour savoir d'où vient ton problème, tu aurais pu faire un debug, et en t'arrêtant sur une des lignes de test, afficher les 2 valeurs (ValeurDemandée et Fruit par exemple), pour voir ce qui clochait.
Je t'encourage d'ailleurs à le faire pour comprendre ton erreur.

Une des méthodes va être de créer une classe qui comportera au moins 2 propriétés, Nom_Produit et Type_Produit, puis de faire une collection de cette classe dans laquelle tu stockeras ta liste.
Lors de la sélection du nom, tu dois alors rechercher le Type_Produit correspondant, et c'est lui que tu testeras au final.

[Marmounet]

Merci m4k-Hurrican
C'est bien là le problème, je n'ai pas d'erreur. Il y a bien 5 dans la variable ValeurDemandée
La variable Listeproduits.fruits=7 ?
Je vois bien que ValeurDemandée est du type Integer

Le test fait bien 5<>7 donc il renvoi False.

J'avais aussi fait le test avec

Code :

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

1
2
3
 
dim valeurDemandée as new Listeproduit
ValeurDemandée=ctype(5, ListeProduits)

Mais le résultat du test est aussi False.

J'ai aussi testé en mettant un Flag <Enum>

Aussi, Je souhaitais quelque chose de plus simple que de créer une nouvelle classe et tout ce qui va avec.

[m4k-Hurrican]

Tu as bel et bien une erreur puisque çà ne fonctionne pas.
5 ne peut être égal à 7 (c'est çà que je voulais que tu vois), on est tous d'accord.

Tu as créé des constantes Fruits, Fleurs, Légume en faisant des "Or" sur des constantes.
Sauf que tu raisonnes avant le test. Les "Or" sont une manipulation mathématiques des valeurs binaires, leur utilisation dans un test est courante. Sur des valeurs comme tu l'as fait est possible, mais dans des cas précis, et il faut savoir exactement pourquoi.
Si ton test avait été fait sur les constantes de base, çà aurait fonctionné. Genre :

Code :

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

if ValeurDemandée = Pomme or ValeurDemandée = Poire or ValeurDemandée = Abricot or ValeurDemandée = Cerise Then...

Car le OR se fait alors sur les égalités, et non sur les valeurs.

Maintenant si ta liste s'agrandit, ou mieux si elle est gérée non pas statiquement (avec des constantes), mais dynamiquement (avec une base de données, un tableau, etc...), cette solution n'est pas utilisable.
D'où la suggestion de créer simplement (c'est pas très compliqué), une classe comportant le nom du produit et son type. Il te suffit alors de trouver l'instance correspondant au nom que tu désires, et de tester le Type de produit associé.

[Invité]

Bonsoir,
Je t'invite à ordonné tes constantes par ordre croissant et par type
Fruits 1 à 5 par exemple fleurs de 6 a 10 légumes de 11 à 15.

Code :

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

1
2
3
4
5
6
7
ValeurDemandée=6
Select case ValeurDemandée
Case 1 to 5: Fruits 
'ou Case pomme,Poires,Abricots :Fruits 
Case 6 to 10: Fleurs 
Case else : Légumes 
End select

[Marmounet]

Bonsoir,
Mes excuses pour un suivi de conversation un peu lâche mais quand le taf appel, il faut y aller.

Je pensai que, justement dans une déclaration Enum, il était possible de créer une sorte de Groupe afin de rassembler des produits ayant une propriété commune. Cela me semblai simple.
La liste que je traite a une longueur courte (au plus 8 éléments non modifiables par l'utilisateur) qui chacun peuvent appartenir à un ou plusieurs groupes ( invariant aussi). Donc la description en Groupe de constantes est vraiment la manière la plus simple d'exprimer cet état.
Actuellement je traite le test dans une fonction qui renvoie True ou False selon la demande utilisateur. Je souhaitais simplifier et exprimer la contrainte de manière plus explicite.
Merci pour vos éclairages.
Marmounet

[StringBuilder]

Je ne connais pas du tout la syntaxe en VB.NET mais ce que tu cherches à faire, c'est une comparaison binaire (bitwise).
Il faut donc utiliser les opérateurs binaires.

Code en C# qui fait ce que tu veux :

Code csharp :

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
80
81
82
83
84
85
86
87
88
89
 
using System;
 
namespace TestEnum
{
    class Program
    {
        static void Main(string[] args)
        {
            int valeur = 0;
            while (true)
            {
                Console.Write("Entrez un nombre (ou autrechose pour sortir) : ");
                string res = Console.ReadLine();
                if (!int.TryParse(res, out valeur))
                {
                    Console.WriteLine("Aurevoir et merci pour le poisson !");
                    break;
                }
 
                // Vérification simple : Rien > valeur > Tout
                if (valeur < (int)TypeProduit.Rien || valeur > (int)TypeProduit.Tout)
                {
                    Console.WriteLine("Vous avez tapé n'importe quoi !");
                    continue;
                }
 
                // Vérification simple : seul 1 bit doit être alumé
                if (PopCount(valeur) != 1)
                {
                    Console.WriteLine("Vous avez tapé n'importe quoi !");
                    continue;
                }
 
                TypeProduit produit = (TypeProduit)valeur;
 
                if ((produit & TypeProduit.Fruit) == produit)
                {
                    Console.WriteLine($"{produit} est un fruit");
                }
                else if ((produit & TypeProduit.Légume) == produit)
                {
                    Console.WriteLine($"{produit} est un légume");
                }
                else if ((produit & TypeProduit.Fleur) == produit)
                {
                    Console.WriteLine($"{produit} est une fleur");
                }
                else
                {
                    Console.WriteLine("Vous avez tapé n'importe quoi !");
                }
                Console.WriteLine();
            }
        }
 
        /// <summary>
        /// Count the number of bits set to 1 in a int
        /// </summary>
        static byte PopCount(int value)
        {
            int result = value - ((value >> 1) & 0x55555555);
            result = (result & 0x33333333) + ((result >> 2) & 0x33333333);
            return (byte)(unchecked(((result + (result >> 4)) & 0xF0F0F0F) * 0x1010101) >> 56);
        }
    }
 
    /// <summary>
    /// On notera que les différents produits sont preprésentés en binaire avec un seul bit à vrai
    /// </summary>
    [Flags()]
    enum TypeProduit : int
    {
        Rien = 0b00000000_00000000,                     //   0
        Pomme = 0b00000000_00000001,                    //   1
        Poire = 0b00000000_00000010,                    //   2
        Abricot = 0b00000000_00000100,                  //   4
        Cerise = 0b00000000_00001000,                   //   8
        Tulipe = 0b00000000_00010000,                   //  16
        Courgette = 0b00000000_00100000,                //  32
        Pomme_De_Terre = 0b00000000_01000000,           //  64
        Rose = 0b00000000_10000000,                     // 128
        Radis = 0b00000001_00000000,                    // 256
        Fruit = Pomme | Poire | Abricot | Cerise,       // 1 + 2 + 4 + 8 = 15 =   0b00000000_00001111
        Fleur = Rose | Tulipe,                          // 128 + 16 = 144 =       0b00000000_10010000
        Légume = Courgette |  Pomme_De_Terre | Radis,   // 32 + 64 + 256 = 352 =  0b00000001_01100000
        Tout = Fruit | Fleur | Légume                   // 15 + 144 + 352 = 511 = 0b00000001_11111111
    }
}

Ce qui donne :

Entrez un nombre (ou autrechose pour sortir) : 1
Pomme est un fruit

Entrez un nombre (ou autrechose pour sortir) : 2
Poire est un fruit

Entrez un nombre (ou autrechose pour sortir) : 3
Vous avez tapé n'importe quoi !
Entrez un nombre (ou autrechose pour sortir) : 4
Abricot est un fruit

Entrez un nombre (ou autrechose pour sortir) : 16
Tulipe est une fleur

Entrez un nombre (ou autrechose pour sortir) : 32
Courgette est un légume

Entrez un nombre (ou autrechose pour sortir) : 0
Vous avez tapé n'importe quoi !
Entrez un nombre (ou autrechose pour sortir) :

[Marmounet]

Bonjour StringBuilder
Ce que tu propose est l'utilisation du mot Flag avant la liste d'une énumération qui indique à VB que les constantes doivent êtres stockées en binaire tel que tu l'expliques.
Et c'est bien une comparaison Bit à Bit afin de vérifier que le mot cherché est bien présent dans la Chaine globale (La Constante Pomme en Binaire est bien comprise dans Fruit qui est l'addition des fruits).
Je ne comprend pas bien le fonctionnement de ta routine de test mais je vais bucher un peu le truc et tout ira bien et je vais garder un appel de fonction pour obtenir mon résultat.

En avançant dans la discussion je m’aperçois que, en fait, c'est bien la fonction que je souhaitais éviter or cette fonction est implicite dans le signe =.

Merci pour ton aide.
Marmounet

[StringBuilder]

Le mot "flag", je l'ai mis car je me suis basé sur un exemple.
Je ne suis pas certain qu'il soit nécessaire dans mon exemple.


Et si, après avoir préparé la structure avec les valeurs adéquat (bien vérifier que chaque "item" a bien 1 et 1 seul bit à vrai) je fais bien des comparaison bitwise :

Code csharp :

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

if ((produit & TypeProduit.Fruit) == produit)

Signifie qu'on fait un ET binaire (porte AND sur le CPU) afin de comparer la valeur saisie et le masque correspondant à "Fruit".

Soit, pour la valeur "Poire" :

Code :

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

1
2
3
4
5
 
  00000000_00000010 // Poire
& 00000000_00001111 // Fuit
-------------------
  00000000_00000010

Tous (le seul) bits de "Poire" étaient à vrai dans "Fruit" donc poire est bel et bien un fruit.

En revanche, avec "Légume" ça ne match pas :

Code :

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

1
2
3
4
5
 
  00000000_00000010 // Poire
& 00000001_01100000 // Fuit
-------------------
  00000000_00000000

Donc on sait que "Poire" n'est pas un "Fruit"

C'est bien une comparaison bitwise.