Wie kann ich überprüfen, ob alle Listenelemente denselben Wert haben, und ihn zurückgeben oder einen "anderen Wert" zurückgeben, wenn dies nicht der Fall ist?

Wenn alle Elemente in einer Liste denselben Wert haben, muss ich diesen Wert verwenden, andernfalls muss ich einen „anderen Wert“ verwenden. Ich kann mir keinen einfachen und klaren Weg vorstellen, dies zu tun.

Siehe auch Ordentliche Methode zum Schreiben einer Schleife mit spezieller Logik für das erste Element in einer Sammlung.

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

Die sauberste Art, die ich mir vorstellen kann. Sie können es zu einem Einzeiler machen, indem Sie val einfügen, aber First () wird n-mal ausgewertet, wodurch die Ausführungszeit verdoppelt wird.

Um das in den Kommentaren angegebene Verhalten "leerer Satz" zu berücksichtigen, fügen Sie einfach eine weitere Zeile vor den beiden oben genannten hinzu:

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

Guter Schnelltest für alle gleich:

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

Obwohl Sie ein solches Gerät sicherlich aus vorhandenen Sequenzoperatoren erstellen können, wäre ich in diesem Fall geneigt, dieses als benutzerdefinierten Sequenzoperator zu schreiben. Etwas wie:

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

Das ist ziemlich klar, kurz, deckt alle Fälle ab und erzeugt nicht unnötig zusätzliche Iterationen der Sequenz.

Dies zu einer generischen Methode zu machen, die funktioniert, IEnumerable<T>bleibt als Übung übrig. :-)

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

Oder wenn Sie sich Sorgen machen, First () für jedes Element auszuführen (was ein gültiges Leistungsproblem sein könnte):

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

Dies mag spät sein, aber eine Erweiterung, die für Wert- und Referenztypen gleichermaßen funktioniert, basierend auf Erics Antwort:

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

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

Eine Alternative zur Verwendung von LINQ:

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

Ich habe festgestellt, dass die Verwendung HashSet<T>für Listen mit bis zu ~ 6.000 Ganzzahlen schneller ist als:

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

Eine geringfügige Abweichung vom obigen vereinfachten Ansatz.

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

Wenn ein Array vom Typ Multidimension wie unten ist, müssen wir unter linq schreiben, um die Daten zu überprüfen.

Beispiel: Hier sind die Elemente 0 und ich überprüfe, ob alle Werte 0 sind oder nicht.
ip1 =
0 0 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";   
    }