C# 多变量间的等式比较

在这种情况下，我需要检查多个变量是否具有相同的数据，例如

var x=1;
var y=1;
var z=1;

我想检查x==1和y==1z==1（它可能是“1”或其他值）。除此之外，我还有没有什么捷径可以实现以下目标

if(x==y==z==1)

这在C#中可能吗

没有其他简单或更有效的方法

if (x == y && y == z && z == 1)

是你能做的最好的，因为

y==z

计算结果为布尔值，您无法将

x

与结果进行比较：

x == (y == z)

|    |

int  bool

我会这样做：

public bool AllEqual<T>(params T[] values) {
    if(values == null || values.Length == 0)
         return true;
    return values.All(v => v.Equals(values[0]));    
}

// ...

if(AllEqual(x, y, z)) { ... }

public bool AllEqual（参数T[]值）{
如果（值==null | |值。长度==0）
返回true；
返回值.All（v=>v.Equals（值[0]）；
}
// ...
如果（AllEqual（x，y，z））{…}

肯尼特是正确的，没有其他更简单或更有效的方法

然而，若您有许多变量，您也可以构建一个值数组，并使用IEnumerable.All方法验证它们都是1。更具可读性，国际海事组织

if (new[] { v1, v2, v3, v4, v5, v6, v7, v8, v9, v10 }.All(x => x == 1))

而不是

if(v1 == 1 && v2 == 1 && v3 == 1 && v4 == 1 && v5 == 1 && v6 == 1 && v7 == 1 && v8 == 1 && v9== 1 && v10 == 1)

---

实际上，我不需要花时间去编码，但是像这样一个使用linq的扩展方法

public bool EqualsToAll<T>(this T element, IEnumerable<T> source)
{
    if(element == null)
        throw new ArgumentNullException(element);

    foreach(var item in source)
    {
        if(!element.Equals(item)
            return false;
    }

    return true;
}

public bool EqualsToAll（此T元素，IEnumerable源代码）
{
if（元素==null）
抛出新的ArgumentNullException（元素）；
foreach（源中的var项）
{
如果（！element.Equals（项）
返回false；
}
返回true；
}

应该可以

---

警告：此代码未经测试，也未在IDE中编写。

这里有一个很好的小递归解决方案，可用于所有类型

class Program
{
    static void Main(string[] args)
    {
        int x = 4, y = 4, z = 4;
        Console.WriteLine(4.IsEqualToAllIn(x, y, z).ToString());
        //prints True

        string a = "str", b = "str1", c = "str";
        Console.WriteLine("str".IsEqualToAllIn(a, b, c).ToString());
        //prints False
    }
}

public static class MyExtensions
{
    public static bool IsEqualToAllIn<T>(this T valueToCompare, params T[] list)
    {
        bool prevResult = true;
        if (list.Count() > 1)
            prevResult = list[0].IsEqualToAllIn(list.Skip(1).ToArray());
        return (valueToCompare.Equals(list[0])) && prevResult;
    }
}

类程序
{
静态void Main（字符串[]参数）
{
int x=4，y=4，z=4；
Console.WriteLine（4.Isequaltallin（x，y，z）.ToString（））；
//打印正确
字符串a=“str”，b=“str1”，c=“str”；
Console.WriteLine（“str.isequaltallin（a，b，c）.ToString（））；
//打印错误
}
}
公共静态类MyExtensions
{
公共静态布尔值IsEqualToAllIn（此T值为比较，参数为T[]列表）
{
bool prevResult=true；
if（list.Count（）>1）
prevResult=list[0]。IsEqualToAllIn（list.Skip（1.ToArray（））；
返回值（valueToCompare.Equals（列表[0]）&&prevResult；
}
}

如果您只想测试x==y==z，您可以使用：

var allEqual = new[] {x, y, z}.Distinct().Count() == 1;

如果要测试它们是否都等于1，请将1添加到集合中：

var allEqual1 = new[] {x, y, z, 1}.Distinct().Count() == 1;

或者使用芬克利夫答案中的

All

。

var x=1；
var x = 1;
var y = 1;
var z = 1;

if (AllEqual(1, x, y, z))    // true
if (AllEqual(2, x, y, z))    // false
if (AllEqual(x, y, z))       // true

var a = 1;
var b = 2;
var c = 3;

if (AllEqual(a, b, c))       // false

// ...

public static bool AllEqual<T>(params T[] values)
{
    if (values == null)
        throw new ArgumentNullException("values");

    if (values.Length < 1)
        throw new ArgumentException("Values cannot be empty.", "values");

    T value = values[0];
    for (int i = 1; i < values.Length; i++)
    {
        if (!value.Equals(values[i]))
            return false;
    }
    return true;
}

变量y=1；
var z=1；
if（AllEqual（1，x，y，z））//true
if（AllEqual（2，x，y，z））//false
if（AllEqual（x，y，z））//true
var a=1；
var b=2；
var c=3；
if（AllEqual（a，b，c））//false
// ...
公共静态布尔AllEqual（参数T[]值）
{
如果（值==null）
抛出新的ArgumentNullException（“值”）；
如果（值。长度<1）
抛出新ArgumentException（“值不能为空。”，“值”）；
T值=值[0]；
for（int i=1；i

我将Mau的解决方案改编成了一个扩展方法。如果他们将它添加到所有值类型的框架中，那就太好了

public static class IntegerExtensions
{
    public static bool EqualsAll(this int subject, params int[] values)
    {
        if (values == null || values.Length == 0)
        {
            return true;
        }

        return values.All(v => v == subject);
    }
}

public static bool AllSame（列表值）
{
返回值.Distinct（）.Count（）==1；
}
公共静态bool AllDifferent（列表值）
{
返回值.Distinct（）.Count（）==values.Count；
}

我是如何做到这一点的：

Debug.Assert(new List<int> { l1.Count, l2.Count, l3.Count, l4.Count }.TrueForAll(
  delegate(int value) { return value == l1.Count; }), "Tables have different size.");

Debug.Assert（新列表{l1.Count，l2.Count，l3.Count，l4.Count}.TrueForAll(
委托（int值）{return value==l1.Count；}），“表的大小不同。”；

对于整型，如何处理：

int x = 3, y = 3, z = 3;

if((x & y & z & 3) == 3)
  //...have same data

用于测试任何非零值。

---

它需要更多的检查才能使其成为可重用的函数。但可能适用于非零相等的内联检查，如OP所述。

与上面jevakallio给出的优秀答案略有不同。查看myValue是否等于列表（数组中）中的任何值：

---

XOR可能适用于您，例如：

var x=1;
var y=1;
var z=1;

然后

是真的

-编辑- 如果要检查所有值是否相同且其值是否为1，请使用：

x ^ y ^ z ^ 1 == 0

添加此扩展名：

public static class Extensions
{
    public static bool EqualsAll<T>(this T subject, params T[] values) =>
        values == null || values.Length == 0 || values.All(v => v.Equals(subject));
}

---

很抱歉，我并不期待这个答案，因为即使我知道我可以通过这样的3个表达式检查来实现。我的问题可能不够清楚。我想在没有和运算符的情况下，通过上面提到的单个表达式来实现。无论如何，感谢您澄清没有更简单的方法。+1.太棒了。我会接受这个答案。这不是多少你知道，这一切都是关于你对你已经知道的东西有多了解。我的答案在这之前看起来很傻。在大集合中要注意的是O（N logn），而公认的解决方案是O（N）。只需在@MichaelAnderson的基础上加上，从性能上讲，这将如何区别（）如果有一个足够大的集合具有不同的值，则执行？因此对于OR（| |）语句，您可以执行.Any而不是.All？如果您选择在if语句中使用此选项，请用括号将^（XOR）运算符括起来，如：if（（x^y^z^1）==0）

var x=1;
var y=1;
var z=1;

x ^ y ^ z == 0

x ^ y ^ z ^ 1 == 0

public static class Extensions
{
    public static bool EqualsAll<T>(this T subject, params T[] values) =>
        values == null || values.Length == 0 || values.All(v => v.Equals(subject));
}

if(1.EqualsAll(x, y, z))