Se istruzione - 'o' ma 'NON' e '

Question

In C Sharp, come posso impostare un'istruzione if che controlla se una delle diverse condizioni è vera? Deve essere solo una delle condizioni, se zero o due o più sono vere, se dovrebbe essere falso.

Answer 1

si potrebbe scrivere un metodo di supporto. Questo ha il vantaggio di cortocircuiti, solo valutare esattamente come molti come necessario,

public static bool IsExactlyOneTrue(IEnumerable<Func<bool>> conditions) { 
    bool any = false; 
    foreach (var condition in conditions) { 
     bool result = condition(); 
     if (any && result) { 
      return false; 
     } 
     any = any | result; 
    } 
    return any; 
} 

Answer 2

Andando per semplicità, si può solo tenere un conteggio parziale:

int totalTrue = 0; 
if (A) totalTrue++; 
if (B) totalTrue++; 
if (C) totalTrue++; 
... 
return (1 == totalTrue); 

Answer 3

Si potrebbe utilizzare comporre la vostra booleani in una sequenza bool e quindi applicare LINQ:

bool[] conditions = new bool[] { cond1, cond2, cond3, cond4 }; 
bool singleTrue = conditions.Count(cond => cond) == 1; 

solo per due booleani, esclusivo o diventa molto più semplice:

bool singleTrue = cond1 != cond2; 

Modifica: Per ottenere on-demand valutazione e corto circuito, è necessario promuovere la nostra sequenza bool in una sequenza Func<bool> (in cui ogni elemento è un delegato funzione incapsula la valutazione di una condizione):

IEnumerable<Func<bool>> conditions = // define sequence here 
int firstTrue = conditions.IndexOf(cond => cond()); 
bool singleTrue = firstTrue != -1 && 
        conditions.Skip(firstTrue + 1).All(cond => !cond()); 

quanto sopra frammento presuppone l'esistenza di un operatore IndexOf predicato-based, che non è disponibile sotto la versione corrente di LINQ ma può essere definita come un metodo di estensione in questo modo:

public static int IndexOf<T>(this IEnumerable<T> source, Func<T, bool> predicate) 
{ 
    int i = 0; 

    foreach (T element in source) 
    { 
     if (predicate(element)) 
      return i; 

     i++; 
    } 

    return -1; 
} 

campione d ata per il test (un punto di interruzione può essere impostato su ogni false o true a seguire di valutazione):

IEnumerable<Func<bool>> conditions = new Func<bool>[] 
{ 
    () => 
     false, 
    () => 
     true, 
    () => 
     false, 
    () => 
     false, 
}; 

Answer 4

credo che questo sarebbe fare il trucco

int i= 0; 
if ((!A || ++i <= 1) && 
     (!B || ++i <= 1) && 
     (!C || ++i <= 1) && 
     ... && 
     (i == 1)) 

Se non ho pensato sbagliato su questo, questo if sarà falso non appena i > 1. Se i non è mai incrementato e raggiungiamo l'ultimo condion, sarà falso dal i == 0

Answer 5

List<Func<Customer, bool>> criteria = new List<Func<Customer, bool>>(); 

criteria.Add(c => c.Name.StartsWith("B")); 
criteria.Add(c => c.Job == Jobs.Plumber); 
criteria.Add(c => c.IsExcellent); 

Customer myCustomer = GetCustomer(); 

int criteriaCount = criteria 
    .Where(q => q(myCustomer)) 
    // .Take(2) // optimization 
    .Count() 
if (criteriaCount == 1) 
{ 
} 

---

implementazione Linq della firma del metodo di Jason:

public static bool IsExactlyOneTrue(IEnumerable<Func<bool>> conditions) 
{ 
    int passingConditions = conditions 
    .Where(x => x()) 
    // .Take(2) //optimization 
    .Count(); 
    return passingConditions == 1; 
} 

Answer 6

La maggior parte di queste risposte saranno lavorare e avere ' buona performance'. Ma la risposta più semplice è:

if((A & !(B || C)) || 
    (B & !(A || C)) || 
    (C & !(A || B))) 
{ 
    ... 
} 

si finisce per valutare A/B/C più di una volta quindi questo è veramente utile solo quando si dispone bools semplici.