Come posso verificare che più booleani abbiano valori identici in C#?

Question

C'è un modo più breve di testare il seguente:

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

ho finito per scrivere un metodo che mi permette di fare questo

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

che si sente più bello ed è molto più leggibile, ma io' Mi chiedo se c'è qualcosa nel quadro che lo fa già?

Answer 1

Bene per prima cosa, è possibile utilizzare una matrice di parametri per rendere più semplice:

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


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

Non credo che troverete qualcosa di più semplice di quello, ad essere onesti. Non l'ho visto da nessun'altra parte o nel framework. Bene, suppongo che ci sia una cosa che potreste fare in LINQ:

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

Ma questo è abbastanza orribile :)

Una versione leggermente più efficiente e cioè:

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

.. . che restituirà false non appena trova il secondo elemento distinto. Con solo 6 elementi non penso che valga la pena di preoccuparsi però :)

Answer 2

Non credo sia una buona idea introdurre una dipendenza in un framework solo per quello.

Answer 3

Questo non è qualcosa che la gente di solito vuole sapere. Potresti facilmente verificare che erano tutti veri solo ed unendoli insieme, o che erano tutti falsi con i loro non-amici. È anche popolare in C++ per lanciare bool in ints e aggiungerli: nel tuo caso, sei in cerca di un totale di 6 o 0. Ma penso che entrambi oscurerebbero qualunque ragione di business tu abbia per sapere che 6 flag sono o tutto vero o tutto falso.

Answer 4

È possibile distribuire il! nell'espressione:

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

È inoltre possibile utilizzare Any o! All anziché aggiungere un nuovo metodo.

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

Answer 5

Solo se a, b, c, d, e ed f sono valori booleani:

il modo più bello è quello di dare uno sguardo in Boolean logic e logic gates per simplify l'equazione.

(Il == è come un XNOR gate per i valori booleani)

Un esempio per voi:

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

è lo stesso di:

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

ma penso che deve essere interessante fare a una rivista della logica che viene a quello

[EDIT] In relazione con l'Hightechrider's answers, la proposizione

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

è equivalente a:

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

Ma Hightechrider's proposition funzionare perfettamente anche se a, b, c, d, e ed f non sono booleani .

Answer 6

È possibile utilizzare questo per controllare che sono tutte vere:

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

e questo per verificare che esse sono tutte false:

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

e si potrebbe combinare sia per verificare che essi siano tutti uguali:

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

Ma francamente, questo non è meglio del tuo soluzione originale :-)

base a quanto precede, ecco una possibile implementazione di 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

Uso BitArray:

Gestisce una matrice compatta di valori di bit, che sono rappresentati come booleani, dove true indica che il bit è su (1) e false indica che il bit è disattivato (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 esempio di codice di applicazione console per la dimostrazione:

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 documentazione sulBitArray

Answer 8

ne dite ..

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

Looks abbastanza elegante per me. :)