Como verificar se todos os itens da lista têm o mesmo valor e retorná-lo ou retornar um "otherValue" se não tiverem?

Se todos os itens em uma lista tiverem o mesmo valor, preciso usar esse valor, caso contrário, preciso usar um "otherValue". Não consigo pensar em uma maneira simples e clara de fazer isso.

Consulte também Maneira clara de escrever loop que possui lógica especial para o primeiro item de uma coleção.

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

Maneira mais limpa que consigo pensar. Você pode transformá-lo em uma linha alinhando val, mas First () seria avaliado n vezes, dobrando o tempo de execução.

Para incorporar o comportamento "conjunto vazio" especificado nos comentários, basta adicionar mais uma linha antes das duas acima:

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

Bom teste rápido para todos iguais:

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

Embora você certamente possa construir esse dispositivo a partir de operadores de sequência existentes, nesse caso, eu estaria inclinado a escrevê-lo como um operador de sequência personalizado. Algo como:

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

Isso é bastante claro, curto, abrange todos os casos e não cria desnecessariamente iterações extras da sequência.

Transformar isso em um método genérico que funciona IEnumerable<T>é deixado como um exercício. :-)

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

Ou se você estiver preocupado em executar o First () para cada elemento (o que pode ser uma preocupação válida de desempenho):

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

Pode ser tarde, mas uma extensão que funciona tanto para tipos de valor quanto de referência com base na resposta de 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;
    }
}

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

Uma alternativa ao uso do LINQ:

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

Eu descobri que o uso HashSet<T>é mais rápido para listas de até 6.000 números inteiros em comparação com:

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

Uma ligeira variação na abordagem simplificada acima.

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

Se uma matriz é do tipo multidimensional como abaixo, precisamos escrever abaixo linq para verificar os dados.

exemplo: aqui os elementos são 0 e eu estou verificando todos os valores são 0 ou não.
ip1 =
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";   
    }