如何检查所有列表项是否具有相同的值并返回它，或者如果没有则返回“otherValue”？

Question

如果列表中的所有项目都具有相同的值，那么我需要使用该值，否则我需要使用“otherValue”。我想不出一个简单明了的方法来做到这一点。当列表为空时，它应该返回“其他”值。

另见Neat way to write loop that has special logic for the first item in a collection.

Answer 1

var val = yyy.First().Value;
return yyy.All(x=>x.Value == val) ? val : otherValue; 

我能想到的最干净的方式。您可以通过内联 val 使其成为单线，但 First() 将被评估 n 次，执行时间加倍。

要合并 cmets 中指定的“空集”行为，您只需在上述两行之前再添加一行：

if(yyy == null || !yyy.Any()) return otherValue;

Answer 2

人人平等的快速测试：

collection.Distinct().Count() == 1

Answer 3

虽然您当然可以使用现有的序列运算符构建这样的设备，但在这种情况下，我倾向于将其编写为自定义序列运算符。比如：

// Returns "other" if the list is empty.
// Returns "other" if the list is non-empty and there are two different elements.
// Returns the element of the list if it is non-empty and all elements are the same.
public static int Unanimous(this IEnumerable<int> sequence, int other)
{
    int? first = null;
    foreach(var item in sequence)
    {
        if (first == null)
            first = item;
        else if (first.Value != item)
            return other;
    }
    return first ?? other;
}

这很清楚，很简短，涵盖了所有情况，并且不会不必要地创建序列的额外迭代。

把它变成一个适用于IEnumerable<T> 的通用方法留作练习。 :-)

Answer 4

return collection.All(i => i == collection.First())) 
    ? collection.First() : otherValue;.

或者，如果您担心为每个元素执行 First()（这可能是一个有效的性能问题）：

var first = collection.First();
return collection.All(i => i == first) ? first : otherValue;

Answer 5

这可能晚了，但根据 Eric 的回答，一个适用于值和引用类型的扩展：

public static partial class Extensions
{
    public static Nullable<T> Unanimous<T>(this IEnumerable<Nullable<T>> sequence, Nullable<T> other, IEqualityComparer comparer = null)  where T : struct, IComparable
    {
        object first = null;
        foreach(var item in sequence)
        {
            if (first == null)
                first = item;
            else if (comparer != null && !comparer.Equals(first, item))
                return other;
            else if (!first.Equals(item))
                return other;
        }
        return (Nullable<T>)first ?? other;
    }

    public static T Unanimous<T>(this IEnumerable<T> sequence, T other, IEqualityComparer comparer = null)  where T : class, IComparable
    {
        object first = null;
        foreach(var item in sequence)
        {
            if (first == null)
                first = item;
            else if (comparer != null && !comparer.Equals(first, item))
                return other;
            else if (!first.Equals(item))
                return other;
        }
        return (T)first ?? other;
    }
}

Answer 6

public int GetResult(List<int> list){
int first = list.First();
return list.All(x => x == first) ? first : SOME_OTHER_VALUE;
}

Answer 7

使用 LINQ 的替代方法：

var set = new HashSet<int>(values);
return (1 == set.Count) ? values.First() : otherValue;

我发现使用 HashSet<T> 对于最多 6,000 个整数的列表相比更快：

var value1 = items.First();
return values.All(v => v == value1) ? value1: otherValue;

Answer 8

与上述简化方法略有不同。

var result = yyy.Distinct().Count() == yyy.Count();

Answer 9

如果一个数组是像下面这样的多维类型，那么我们必须在 linq 下面写来检查数据。

示例：这里的元素为 0，我正在检查所有值是否为 0。
ip1=
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0

    var value=ip1[0][0];  //got the first index value
    var equalValue = ip1.Any(x=>x.Any(xy=>xy.Equals()));  //check with all elements value 
    if(equalValue)//returns true or false  
    {  
    return "Same Numbers";  
    }else{  
    return "Different Numbers";   
    }