C# - Y a-t-il un moyen de vérifier si une variable est une de plusieurs choses?

Question

donc actuellement je fais ceci:

if(variable == thing1 || variable == thing2 || variable == thing3) 

Mais ce n'est pas super lisible. Ce que je voudrais faire est quelque chose comme ceci:

if(variable == thing1 || thing2 || thing3) 

Une telle syntaxe existe-t-elle dans C#?

Answer 1

Si la syntaxe concise est très important pour vous, vous pouvez définir une méthode d'extension:

public static class ObjectExtensions 
{ 
    public static bool In<T>(this T item, params T[] elements) 
    { 
     return elements.Contains(item); 
    } 
} 

Vous pouvez ensuite utiliser cela comme si:

if (variable.In(thing1, thing2, thing3)) 

Cela dit, si la liste vérifiée ne changera pas, je préférerais le déclarer comme un champ en lecture seule statique, et appeler Contains par rapport à cela. La méthode d'extension ci-dessus peut entraîner l'attribution d'un nouveau tableau chaque fois qu'il est appelé, ce qui peut nuire aux performances dans les boucles serrées.

private static readonly Thing[] _things = new [] { thing1, thing2, thing3 }; 

public void ProcessThing(Thing variable) 
{ 
    if (_things.Contains(variable)) 
    { 
     // ... 
    } 
} 

En outre, si la liste en cours de vérification contre contient plus de quelques articles, utilisez un HashSet<T> à la place.

Answer 2

Vous cound faire:

int[] aux=new int[]{1,2,3}; 
if(Array.contains(aux, value)) 

Answer 3

Mettez les chaînes de test dans une liste ou un tableau et appelez Contains:.

var testers = new [] { "foo1", "foo2" }; 

if (testers.Contains("subject")) 
{ 
    // test succeeded 
} 

Comme alternative:

if (new [] {"foo1", "foo2"}.Contains("subject")) 
{ 
    // test succeeded 
} 

Answer 4

Si vous mettez toutes vos choses dans une collection de quelque sorte alors oui, vous pouvez utiliser LINQ et Any

https://msdn.microsoft.com/en-us/library/system.linq.enumerable.any(v=vs.110).aspx

Answer 5

Certaines personnes préfèrent une méthode d'extension:

public static bool IsOneOf<T>(this T self, params T[] values) => values.Contains(self); 

ou similaire.

Ensuite, vous pouvez dire:

if (variable.IsOneOf(thing1, thing2, thing3)) 

Oups, je vois Douglas était d'abord avec cette approche.

Il utilise implicitement le comparateur d'égalité par défaut de T.

L'inconvénient est que vous créez une méthode d'extension à tous les types. Si vous n'en avez besoin que pour, par exemple, string, vous pouvez bien sûr créer une méthode d'extension moins générale.

Answer 6

Vous avez quelques options.

1. Utilisez switch (si thing1-thing3 sont des expressions constantes)

   switch variable 
       case thing1: 
       case thing2: 
       case thing3: 
        DoSomething(); 
        break; 
   

2. Utilisez un RegEx (fonctionne uniquement pour les chaînes)

   if (RegEx.Match(variable, "^(thing1|thing2|thing3)")) 
   { 
       DoSomething(); 
   } 
   

3. Utilisez un tableau

   string[] searchFor = new string[] {thing1, thing2, thing3}; 
   if (searchFor.Contains(variable)) 
   { 
       DoSomething(); 
   }