C# 确定值是否不同

假设我有4个变量

bool value1 = false;
bool value2 = false;
bool value3 = true;
bool value4 = false;

而且它们的值都不相同（都是true

|

都是false）

我发现了两种方法，不管怎样，它们都不容易理解

bool areDifferent = !(value1 == value2 == value3 == value4);

及

---

问题：是否有其他方法在可读性/可理解性方面更好？

尽管我个人更喜欢您的第一种方法，但以下方法也适用

bool value1 = false;
bool value2 = false;
bool value3 = true;
bool value4 = false;

var values = new[] { value1, value2, value3, value4 };

bool areDifferent = values.Any(v => v) && values.Any(v => !v);

---

为了可读性和理解性，我将交换逻辑。当您检查值是否不同时，不清楚-所有值都应该不同（考虑整数值1、2、3），或者值可以相等，但至少有一个不同的值（1、2、1）？当您检查所有值是否相等时，总是很清楚

我会将此逻辑提取到命名良好的方法中（如果需要，甚至可以将其设置为泛型）：

使用声明式方法，您的代码描述您正在做什么，而不是告诉读者如何做，让读者自己去理解什么

---

更新：如果您总是处理四个布尔值，检查它们是否都相等的最简单方法是

(value1 ^ value2) || (value2 ^ value3) || (value3 ^ value4)

---

但就可读性而言，任何命令式方法都比声明式方法差，您可以组合位并检查

int value = (value1 ? 8 : 0) |
            (value2 ? 4 : 0) |
            (value3 ? 2 : 0) |
            (value4 ? 1 : 0);
return value != 0 && value != 15;

---

为了理解目的，我们可以创建一个方法并使用if块

public bool areDifferent(bool value1, bool value2, bool value3, bool value4)
{
    if(value1 == value2)
        if(value2 == value3)
            if(value3 == value4)
                return false;
                    
    return true;
}

---

也许Linq足够声明性

var values = new[] { false, false, true, false };
bool notAllEqual = values.Any(x => x != values.First());

或者：

var values = new[] { false, false, true, false };
bool allEqual = values.All(x => x == values.First());
if (!allEqual)
{
     // They are different
}

---

你说你想检查你的元素是否

都是真的，都是假的

给你一张单子

var values=新列表{value1，value2，value3，value4}在这些元素中，代码中最接近的表示形式是：

var areDifferent = !(values.All(v => v == true) || values.All(v => v == false));

但就可读性而言，我更喜欢：

var areEqual = values.All(v => v == true) || values.All(v => v == false);

然后检查：

 if (!areEqual)
 {
     // Do something
 }

但这只是个人偏好。
在我看来，这似乎是一种代码味道，您可能需要重构代码，而不是寻找更好的方式来显示布尔值

如果不提供实际的代码，您总是会得到假设而不是答案

无论如何，对于您的特定问题，您可以创建一个
公共静态类
，并将其用作结果测试仪，以通过代码验证所有类型的结果。通过这种方式，您可以重用它，并且更具可读性

例如：

public static class Validate
{
    public static bool AreEqual(params bool[] values) => AreTrue(values) || AreFalse(values);
    
    public static bool AreTrue(params bool[] values) => values.All(x => x == true);
    
    public static bool AreFalse(params bool[] values) => values.All(x => x == false);
}

然后像这样使用它：

bool value1 = false;
bool value2 = false;
bool value3 = true;
bool value4 = false;

if(Validate.AreEqual(value1 , value2 , value3 , value4))
{
    // do something
}

通用方法：

static bool AreDifferent(params bool[] values)
{
    var tmp = values.Select((value, index) => value ? 1 << index : 0).Aggregate((i, j) => i | j);
    return tmp != 0 && tmp != (1 << values.Length) - 1;
}

静态布尔值不同（参数布尔值[]）
{
var tmp=值。选择（（值，索引）=>值？1 i | j）；
返回tmp！=0&&tmp！=（1）我觉得这两行代码都可读性很好，也很容易理解。这似乎是一个完全主观的问题，对于StackOverflow来说可能不是一个很好的问题。如果你不明白代码在做什么，你可以试着花点时间来理解代码在那里做什么。它们看起来都很容易理解。作为替代，你可以使用
bool areSame
并使用
！AreName
检查是否存在差异。这是否回答了您的问题？@Impostor任何命令式代码在可读性/可理解性方面都不好。而且，您的第一种方法是不正确的。尝试使用
true，false，true，false
查看有什么错误
value1==value2==value3==value4
这是不对的。你是在比较比较比较结果，而不是价值观本身。这是个好主意，但这可能是OP想要走的相反方向，因为易于理解。我同意。他/她的想法足够好。不错。有点老套和有限，但仍然……你启发了我。这对错误的价值观不起作用……如果所有值都是false，您的方法将返回false，但值是相等的。@Marmellad修复。谢谢；）。
！=
比
^
更容易理解。另一个选项是
！（value1==value2&&value2==value3&&value3==value4）
public static class Validate
{
    public static bool AreEqual(params bool[] values) => AreTrue(values) || AreFalse(values);
    
    public static bool AreTrue(params bool[] values) => values.All(x => x == true);
    
    public static bool AreFalse(params bool[] values) => values.All(x => x == false);
}

bool value1 = false;
bool value2 = false;
bool value3 = true;
bool value4 = false;

if(Validate.AreEqual(value1 , value2 , value3 , value4))
{
    // do something
}

static bool AreDifferent(params bool[] values)
{
    var tmp = values.Select((value, index) => value ? 1 << index : 0).Aggregate((i, j) => i | j);
    return tmp != 0 && tmp != (1 << values.Length) - 1;
}