Comment puis-je tester si plusieurs booléens ont des valeurs identiques dans C#?

Question

Y at-il un chemin plus court de tester les éléments suivants:

if (!((a == b) && (a == c) && (a == d) && (a == e) && (a == f))) 

J'ai fini par écrire une méthode qui me permet de le faire

if (!AllEqual(new[] { a, b, c, d, e, f })) 

qui se sent plus agréable et est beaucoup plus facile à lire, mais je Je me demande s'il y a quelque chose dans le cadre qui le fait déjà?

Answer 1

Eh bien pour une chose, vous pouvez utiliser un tableau de paramètres pour le rendre plus simple:

public static bool AllEqual<T>(params T[] values) 
... 


if (AllEqual(a, b, c, d, e, f)) 
{ 
    ... 
} 

Je ne pense pas que vous trouverez rien de plus simple que cela, pour être honnête. Je n'ai vu cela nulle part ailleurs, ou dans le cadre. Eh bien, je suppose qu'il ya une chose que vous pourriez faire dans LINQ:

if (new { a, b, c, d, e, f }.Distinct().Count() == 1) 

Mais c'est assez horrible :)

Une version légèrement plus efficace de savoir:

if (!(new { a, b, c, d, e, f }).Distinct().Skip(1).Any())) 

.. qui retournera faux dès qu'il trouvera le second élément distinct. Avec seulement 6 éléments, je ne pense pas que ça vaut la peine de s'inquiéter si :)

Answer 2

Je ne pense pas que ce soit une bonne idée d'introduire une dépendance à un framework uniquement pour cela.

Answer 3

Ce n'est pas quelque chose que les gens veulent généralement savoir. Vous pourriez facilement vérifier qu'ils étaient tous vrais en les associant et en les associant, ou qu'ils étaient tous faux en associant leurs non-croyants. Il est aussi très populaire en C++ de lancer des booléens et de les additionner - dans votre cas, vous cherchez un total de 6 ou de 0. Mais je pense que ces deux raisons obscurciraient votre raison d'être sachant que 6 drapeaux sont soit tout vrai ou tout faux.

Answer 4

Vous pouvez distribuer le! dans l'expression:

if ((a != b) || (a != c) || (a != d) || (a != e) || (a != f))) 

Vous pouvez également utiliser Any ou! All plutôt que d'ajouter une nouvelle méthode.

if (new[]{b, c, d, e, f}.Any(x => x != a)) ... 

Answer 5

Seulement si a, b, c, d, e et f sont des valeurs booléennes:

La façon la plus agréable est de jeter un oeil à Boolean logic et logic gates à simplify votre équation.

(Le == est comme un XNOR gate pour les valeurs booléennes)

Un exemple pour vous:

(!((a == b) && (a == c) && (a == d) && (a == e) && (a == f))) 

est le même que:

((a^b) || (a^c) || (a^d) || (a^e) || (a^f)) 

Mais je pense qu'il doit être intéressant faire à une revue de la logique qui vient à cela

[EDIT] En relation avec le Hightechrider's answers, la proposition

((a^b) || (a^c) || (a^d) || (a^e) || (a^f)) 

est équivalent à:

((a != b) || (a != c) || (a != d) || (a != e) || (a != f)) 

Mais Hightechrider's proposition fonctionner parfaitement, même si a, b, c, d, e et f ne sont pas booléens .

Answer 6

Vous pouvez l'utiliser pour vérifier qu'ils sont tout à fait vrai:

if (a && b && c && d && e && f) { 
    ... 
} 

et cela pour vérifier qu'ils sont faux:

if (!(a || b || c || d || e || f)) { 
    ... 
} 

et vous pouvez combiner les deux pour vérifier qu'ils sont tous égaux:

if ((a && b && c && d && e && f) || !(a || b || c || d || e || f)) 
    ... 
} 

Mais très franchement, ce n'est pas mieux que votre solution originale :-)

Sur la base de ce qui précède, voici une mise en œuvre possible de AllEqual:

public static bool AllEqual(bool[] values) 
{ 
    bool andTerm = true; 
    bool orTerm = false; 
    foreach (bool v in values) 
    { 
     andResult &= v; 
     orResult |= v; 
    } 
    return andTerm || !orTerm; 
} 

Answer 7

Utilisation BitArray:

gère une gamme compacte de valeurs de bits, qui sont représentés comme booléens, où vrai indique que le bit est sur (1) et faux indique que le bit est off (0).

// Your collection of bits 
bool a = false, b = false, c = false; 
// get them into an array 
bool[] d = new bool[] { a, b, c }; 
// intialize BitArray with that array 
System.Collections.BitArray e = new System.Collections.BitArray(d); 
// use OfType<>, Any<>, All<> 
if (Convert.ToBoolean(e.OfType<bool>().Any<bool>(condition => condition.Equals(true)) && e.OfType<bool>().Any<bool>(condition => condition.Equals(false)))) Console.WriteLine("some one is TRUE!."); 

Un exemple de code d'application console pour la démonstration:

class Program 
    { 
     static void Main(string[] args) 
     { 
      bool a = false, b = false, c = false; 
      bool[] d = new bool[] { a, b, c }; 
      System.Collections.BitArray e = new System.Collections.BitArray(d); 
      if (Convert.ToBoolean(e.OfType<bool>().Any<bool>(condition => condition.Equals(true)) && e.OfType<bool>().Any<bool>(condition => condition.Equals(false)))) Console.WriteLine("some one is TRUE!."); 
      if (Convert.ToBoolean(e.OfType<bool>().Any<bool>(condition => condition.Equals(true)) && e.OfType<bool>().Any<bool>(condition => condition.Equals(false)))) Console.WriteLine("some one is FALSE!."); 
      if (Convert.ToBoolean(e.OfType<bool>().All<bool>(condition => condition.Equals(true)))) Console.WriteLine("All of them are TRUE!."); 
      if (Convert.ToBoolean(e.OfType<bool>().All<bool>(condition => condition.Equals(false)))) Console.WriteLine("All of them are false!."); 
      Console.ReadLine(); 
     } 
    } 

MSDN Documentation surBitArray

Answer 8

Que diriez-vous ..

List<bool> arr = new List<bool>{ a, b, c, d, f }; 
bool allEqual = arr.TrueForAll(x => { return x; }) || arr.TrueForAll(x => { return !x; }); 

Looks assez élégant pour moi. :)