你可以写一个帮手方法。这个方法的优点是短路, 只能精确地评估所需的数量,

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

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

执行杰森方法签字的林克:

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

您可以将您的布尔合成为 bool 序列, 然后应用 LINQ :

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

仅针对两个排他性或简单得多的布尔:

bool singleTrue = cond1 != cond2;

Edit :为了实现点火评价 和 短路路,我们需要将我们的 bool 序列推广为 Func<bool> 序列(其中每个元素是包含条件评价的函数代表):

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

上述片段假定存在一个以上游为基础的 Indexof 操作员,根据目前版本的LINQ, 无法使用该操作员,但可被界定为类似的扩展方法:

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

用于测试的样本数据(可在每个 false 或 ret 上设定一个断点,以跟踪评估):

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

为了简单起见,你可以保持一个计数:

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

我觉得这样能解决问题

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

如果我没有错觉, 只要 i> 1 , 这个 if 就会是假的。 如果 i> 1 从未加载, 我们到达最后的孔, 那么由于 i = 0 将是假的 。

但最简单的答案是:

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

最后,你对 A/B/C 的评审超过一次,因此,只有在有简单的布尔时才真正有用。