La meilleure façon de vérifier plusieurs conditions booléennes en C# si les déclarations

J'ai 3 valeurs booléennes sur mon code (C#) et un int32 bien ça dépend de ce que les booléens sont true et false.
Quel est le meilleur moyen pour y parvenir d'une autre manière que si des déclarations comme:

if(a && b && !c)
   d = 1;
if(a && !b && !c)
   d = 2;
//etc.. ect...

EDIT: Les 3 booléens doivent avoir toutes les combinaisons possibles pour définir la valeur int32.

EDIT 2: La valeur de "d" peut être le même pour les deux booléens comparations.

Si il y a toujours exactement trois booléens, vous pouvez créer une table à l'avance et ensuite il suffit de rechercher l'élément en utilisant les opérations booléennes comme clés.
Un tableau d'entiers puis le 3 booléens utilisés comme bits d'index à l'entrée. Type de représentation compacte d'un arbre binaire.
EDIT: ma réponse montre comment calculer un "indice de combinaison" de la constituante conditions

OriginalL'auteur Phoenix_uy | 2013-04-09

  1. 26

    C'est mieux capter l'intention de l'opération au lieu de l'explicite de vérifier si les valeurs booléennes.

    Par exemple:

    public void Check()
{
   if (HasOrdered())
   {
      //do logic
   }
}

private bool HasOrdered()
{
    return a && !b && !c;
}

private bool HasBooked()
{
    return a && b && !c;
}
    +1 entièrement d'accord, selon lequel est le plus compact de façon à vérifier que les conditions n'oublions pas le domaine.
    +1 ici aussi. J'ai encore posté ma réponse parce qu'il n'est pas clair à partir de l'OP que son scénario se prête, pour "les nom de domaine descriptif'
    Si il veut faire laconique code de ce genre de défaites le but
    Je pense que c'est mon meilleur choix...
    Mmm. Une fois la modification de la valeur de Q, de ma réponse semble plus utile

    OriginalL'auteur Davin Tryon

  2. 11

    Vous pouvez utiliser un Karnaugh carte de réduire vos équations et d'avoir moins d'ifs.

    https://en.wikipedia.org/wiki/Karnaugh_map

    C'est la meilleure solution, je suis choqué beaucoup de gens ne le conseille pas.
    beaucoup de gens préfèrent tout simplement d'écrire la logique dès qu'il surgit, pas combine efficacement, finalement; K-cartes se concentrer sur les résultats et impitoyablement éliminer toutes les informations à partir de l'entrée qui n'influence pas le résultat de plus. Cette information est donc plus apparente de la source. Hene, la source n'est plus un reflet des exigences fonctionnelles. C'est difficile pour prouver à droite, pas de facile. Encore plus difficile à maintenir (modifier). Au lieu de cela, vous devez laisser le compilateur vous soucier de l'optimisation (ce qui peut se produire même après l'inlining).

    OriginalL'auteur SamFisher83

  3. 2

    Je pense que ce que vous faites maintenant est parfaitement bien et toute autre solution serait descendu de la préférence.

    Ma préférence, où il s'applique, serait de séparer les vérifie si possible.

     if (!a)
    return;
 if (!b)
    return;
 if (!c)
    return;

    Ce serait utile dans le cas où vous avez besoin de vérifier certaines prereqs avant de délivrer une fonction, comme si l'utilisateur s'est connecté, si un paramètre existe et est dans le bon contexte, avec d'autres éléments.

    Comme je l'ai dit, cela pourrait ne pas s'appliquer, mais je voulais juste exprimer mon opinion

    OriginalL'auteur PsyKzz

  4. 2

    Vous pourriez faire la table de recherche indication donnée par @Adriano, en supposant que vous avez lookup_table rempli avec des valeurs de l'indice [0..8):

    var index = new [] { a,b,c }.Aggregate(0, (a,i) => return 2*a + (i?1:0));

int d = lookup_table[index];

    Modifier La modification de la question de cette pertinence: Ce que j veux dire?

    Si c'est le nombre de fausses valeurs (possible à partir de l'exemple de code), en font

    int d = new [] { a,b,c }.Count(b => !b);

    OriginalL'auteur sehe

  5. 0

    Je ne vois rien de mal avec la façon dont vous le faites, mais si le résultat est le même pour plusieurs conditions que vous peut être en mesure de simplifier si par la création d'une table de vérité et de simplifier les conditions.

    Par exemple, si d devrait être 0 à tout moment a est faux vous pouvez simplifier:

    if(a) 
   if(b && !c)
       d = 1;
   if(!b && !c)
       d = 2;
   ...
else
    d = 0;

    Ou si il y a un modèle mathématique (par exemple,a, b, et c représentent les trois chiffres d'un nombre binaire) alors que vous pourriez faire peu d'arithmétique.

    Si, toutefois, vous avez 8 distinctes résultats (une pour chaque combinaison de a, b, et c) puis votre méthode est très bien.

    OriginalL'auteur D Stanley