2010-01-07 6 views
2
int a, b, c, d, e; 
a = b = c = d = e = 1; 

if ((a==b) && (b==c) && (c==d) && (d==e)) 
{ 
    Console.WriteLine("that syntax is horrible"); 
} 

Y a-t-il une façon plus élégante de tester l'égalité multiple comme ci-dessus?enchaîner les booléens en C#

peut-être un AreEqual(params obj[]) ou quelque chose? J'avais un google mais je n'ai rien trouvé.

+0

Elégant: (a & b & c & d & e) == (a | b | c | d | e), mais pas facilement compris cependant. – Skizz

Répondre

10

Une mise en œuvre possible de AreEqual(params object[] objects):

(Suivant les conseils de Jon Skeet, voici une version générique)

bool AreEqual<T>(params T[] objects) 
{ 
    if (objects.Length <= 1) return true; 
    return objects.Skip(1).All(x => x.Equals(objects[0])); 
} 

Le Skip(1) est pas strictement nécessaire soit.

+2

ouais, linq est la voie à suivre :-) –

+0

merci Aviad, je sais que c'est trivial à mettre en œuvre, je pensais juste qu'il existe déjà une méthode appropriée. – fearofawhackplanet

+0

Je voudrais en faire une méthode générique au lieu de prendre 'object []' si ... –

3

Non, c'est le moyen le plus raisonnable (je veux dire le plus lisible, qui est le plus important). La vraie question est, pourquoi avez-vous besoin de faire cela? Il semble être une mauvaise conception en premier lieu ...

+0

comment diable peut-il être mauvaise conception à besoin de tester si un tas de choses sont égales? Êtes-vous honnêtement en disant qu'il n'y a aucune raison possible de jamais besoin de faire cela? c'est exactement le genre de commentaire 'générique' que je trouve si frustrant avec ce site. Souhaitez-vous que je publie toutes les lignes de code 50K, afin que vous puissiez comprendre pourquoi je veux faire cela? – fearofawhackplanet

+0

À peu près, je dis que oui; pas de raison particulière de se fâcher à ma réponse si. Je vais vous laisser faire. –

+2

Je ne pense pas qu'il voulait dire que vous n'auriez jamais besoin de tester si un tas de choses sont égales, juste qu'il peut y avoir une façon plus concise de faire les choses (en fonction du reste de votre code). –

4

Voici une version générique qui évitera la boxe (et être plus type sécurité au moment de la compilation):

public static bool AllEqual<T>(T firstItem, params T[] items) 
{ 
    // Omitted error checking 
    EqualityComparer<T> comparer = EqualityComparer<T>.Default; 
    foreach (T item in items) 
    { 
     if (!comparer.Equals(firstItem, item)) 
     { 
      return false; 
     } 
    } 
    return true; 
} 

Notez que ce ne sera pas aussi pratique si vous voulez vraiment passer un tas de valeurs vous avez déjà un tableau, mais évite les problèmes avec les tableaux vides - et signifie que vous n'avez aucune comparaison redondante.

+0

Ce n'est pas la même chose que l'original; (Si vous remplacez 'Equals' cela utilisera cette implémentation). –

+1

@silky: Quelle version proposez-vous n'utiliserait pas les Equals surchargés? La seule différence serait que quelqu'un ait implémenté Equals (object) d'une manière différente de leur implémentation de IEqualityComparer - auquel cas ils ont de plus gros problèmes IMO. –

+0

Jon: L'original * (c'est-à-dire le code OPs). Et non, cela ferait une différence s'il voulait réellement faire une comparaison de référence. C'est assez improbable, c'est sûr, mais cela montre la nocivité d'une conversion naïve à un plan élaboré qui est finalement, à mon humble avis, moins lisible et même pas nécessaire. –

0

Si vous comparez types simples et vous n'avez quelques cas d'utilisation, vous pouvez créer quelques méthodes utilitaires tels que:

bool AllEqual(int first, params int[] numbers) 
    { 
     return numbers.All(x => x == first); 
    } 
0

C'est amusant

int a, b, c, d, e; 
a = b = c = d = e = 1; 

if ((a & b & c & d) == e) 
{ 
    Console.WriteLine("that syntax is horrible"); 
} 

et c'est peut-être mieux

int a, b, c, d, e; 
a = b = c = d = e = 1; 
if (new[] {a, b, c, d, e}.All(i => i == a)) 
{ 
    Console.WriteLine("Funky chicken"); 
} 
+0

Ce code donnera de mauvais résultats. Notez que '&' fait un bit et. Le résultat est correct * si * toutes les valeurs sont égales, mais il * peut * être incorrect pour des valeurs différentes (c'est-à-dire que le résultat sera toujours "vrai" bien que les valeurs ne soient pas toutes égales). –

+0

heh c'est donc :) – mcintyre321

Questions connexes