如何测试多个布尔值在c#中是否具有相同的值？

是否有一种较短的方法来测试以下各项：

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

我最后写了一个方法，让我可以这样做

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

---

这感觉更好，可读性也更高，但我想知道框架中是否有什么东西已经做到了这一点？

我认为仅为此目的而向框架引入依赖性不是一个好主意。

人们通常不想知道这一点。你可以很容易地通过把它们放在一起检查它们是否都是真的，或者通过把它们的错放在一起检查它们是否都是假的。它也很流行，在C++中把BOOLS投射到int并添加它们——在你的情况下，你会寻找总共6或0个。但我认为这两个都会掩盖你知道6个标志要么全是真的，要么全是假的任何商业理由。

首先，你可以使用参数数组来简化它：

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


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

但这相当可怕：）

更有效的版本是：

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

---

。。。一旦找到第二个不同的元素，它将返回false。虽然只有6个元素，但我认为不值得担心：）

您可以分发！在表达式中：

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

您也可以使用

Any

或<代码>全部而不是添加新方法

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

---

仅当a、b、c、d、e和f是布尔值时：

更好的方法是看一看你的等式

（

==

类似于布尔值的函数）

给你举个例子：

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

与以下内容相同：

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

但我认为这一定是一个有趣的做法，以一个逻辑的revue，来达到这一点

[编辑]与命题相关的

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

相当于：

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

---

但即使a、b、c、d、e和f不是布尔数，也能完美地工作。

您可以使用此项检查它们是否都是真的：

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

这是为了检查它们是否都是假的：

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

您可以将两者结合起来检查它们是否都相等：

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

但坦率地说，这并不比您原来的解决方案好：-）

基于以上内容，以下是

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

使用：

管理位值的紧凑数组， 以布尔形式表示， 其中，true表示位为 on（1）和false表示位为 关闭（0）

//您的位集合
布尔a=假，b=假，c=假；
//把他们排成一列
bool[]d=新bool[]{a，b，c}；
//使用该数组初始化BitArray
System.Collections.BitArray e=新的System.Collections.BitArray（d）；
//使用类型、任意、全部
if（Convert.ToBoolean（e.OfType（）.Any（condition=>condition.Equals（true））和&e.OfType（）.Any（condition=>condition.Equals（false）））Console.WriteLine（“有一个是真的！”）；

示例控制台应用程序代码用于演示：

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

类程序
{
静态void Main（字符串[]参数）
{
布尔a=假，b=假，c=假；
bool[]d=新bool[]{a，b，c}；
System.Collections.BitArray e=新的System.Collections.BitArray（d）；
if（Convert.ToBoolean（e.OfType（）.Any（condition=>condition.Equals（true））和&e.OfType（）.Any（condition=>condition.Equals（false）））Console.WriteLine（“有一个是真的！”）；
if（Convert.ToBoolean（e.OfType（）.Any（condition=>condition.Equals（true））和&e.OfType（）.Any（condition=>condition.Equals（false）））Console.WriteLine（“有人是假的！”）；
if（Convert.ToBoolean（e.OfType（）.All（condition=>condition.Equals（true）））Console.WriteLine（“它们都是true！”）；
if（Convert.ToBoolean（e.OfType（）.All（condition=>condition.Equals（false）））Console.WriteLine（“它们都是false！”）；
Console.ReadLine（）；
}
}

MSDN文档关于

如何

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

List arr=新列表{a，b，c，d，f}；
bool allEqual=arr.TrueForAll（x=>{return x；}）| arr.TrueForAll（x=>{return！x；}）；

---

在我看来很优雅。：）

你的解决方案是我脑海中能想到的最好的解决方案。他说这个框架——就像我想象的.NET主框架一样。+1我还建议OP不要使用6个bool变量，而是使用一个

bool[]

，使用

.Distinct

@Danny:我认为这取决于上下文-如果变量有非常不同的含义，而这些含义恰好是有意义的，那么将它们分开是有意义的。如果它们更相似，例如“是否填写了字段1，是否填写了字段2”等等，那么数组确实会更好。感谢param数组的想法。False：在

（a&&b&&c&&d&&e&&f）

中，如果a、b、c、d、e和f是

true

，则您的解决方案返回

true

，而

（！（a==b）和（a==c）和（a==d）和（a==e）和（a==f））

返回

False

，和

！（a | b | c | d | e | f）

返回

true

如果a、b、c、d、e和f是

false

而

（！（a==b和（a==c）和（a==d）和（a==e和（a==f））

返回

false

。。。当a、b、c、d、e和f相等时，第三个总是返回

true

，而不是

（！（（a==b）和&（a==c）和&（a==d）和&（a==e）和&（a==f））

在这种情况下，他们总是返回

false

。@G.Qyy：问题的标题是：“如何测试多个布尔值在c#？”。问题中的代码片段实际上使用该函数来测试它们的值是否不相等，但OP明确要求的是

AllEqual

函数。我的回答解释了：1）如何检验所有的正确，2）如何检验所有的错误，3）如何检验所有的相等。我的代码按我说的做。你在这一点上是对的：我知道他想重现它的第一次测试的行为，我关心一些标题，因为它们很少暴露问题的完全复杂性。。。当然，你的代码是正确的

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

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