If statement - 'or' but NOT 'and'

Question

In C Sharp, how can I set up an if statement that checks if one of several conditions is true? It must be only one of the conditions, if zero or two or more are true the if should be false.

Answer 1

You could write a helper method. This has the advantage that it short circuits, only evaluating exactly as many as necessary,

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

You could use compose your booleans into a bool sequence and then apply LINQ:

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

For just two booleans, exclusive or becomes much simpler:

bool singleTrue = cond1 != cond2;

Edit: To achieve on-demand evaluation and short-circuiting, we need to promote our bool sequence into a Func<bool> sequence (where each element is a function delegate encapsulating the evaluation of a condition):

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

The above snippet assumes the existence of a predicate-based IndexOf operator, which is not available under the current version of LINQ but may be defined as an extension method like so:

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;
}

Sample data for testing (a breakpoint may be set on each false or true to follow evaluation):

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

Answer 3

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)
{
}

---

Linq implementation of Jason's method signature:

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

Answer 4

Going for simplicity, you could just keep a running count:

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

Answer 5

I think this would do the trick

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

If I didn't think wrong on this, this if will be false as soon as i > 1. If i is never incremented and we reach the last condion, will be false since i == 0

Answer 6

Most of these answers will work and have 'good performance'. But the simplest answer is:

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

You do end up evaluating A/B/C more than once so this is really only useful when you have simple bools.