web-dev-qa-db-fra.com

Comparaison de plusieurs chaînes avec C #

Disons que je dois comparer si la chaîne x est "A", "B" ou "C".

Avec Python, je peux utiliser opérateur pour vérifier cela facilement.

if x in ["A","B","C"]:
    do something

Avec C #, je peux faire

if (String.Compare(x, "A", StringComparison.OrdinalIgnoreCase) || ...)
    do something

Peut-il être quelque chose de plus similaire à Python?

AJOUTÉE

J'avais besoin d'ajouter System.Linq pour pouvoir utiliser Contain (), insensible à la casse.

using System;
using System.Linq;
using System.Collections.Generic;

class Hello {
    public static void Main() {
        var x = "A";

        var strings = new List<string> {"a", "B", "C"};
        if (strings.Contains(x, StringComparer.OrdinalIgnoreCase)) {
            Console.WriteLine("hello");
        }
    }
}

ou

using System;
using System.Linq;
using System.Collections.Generic;

static class Hello {
    public static bool In(this string source, params string[] list)
    {
        if (null == source) throw new ArgumentNullException("source");
        return list.Contains(source, StringComparer.OrdinalIgnoreCase);
    }

    public static void Main() {
        string x = "A";

        if (x.In("a", "B", "C")) {
            Console.WriteLine("hello");
        }
    }
}
c#string
20
prosseek

Utilisez Enumerable.Contains<T> qui est une méthode d’extension sur IEnumerable<T>:

var strings = new List<string> { "A", "B", "C" };
string x = // some string
bool contains = strings.Contains(x, StringComparer.OrdinalIgnoreCase);
if(contains) {
    // do something
}
25
jason
if ((new[]{"A","B","C"}).Contains(x, StringComparer.OrdinalIgnoreCase))
18
adrianm

Pourquoi oui, il y a un fil classique ici sur StackOverflow avec une méthode d'extension qui ferait exactement ce que vous recherchez.

Utilisation des méthodes d'extension

public static bool In<T>(this T source, params T[] list)
{
  if(null==source) throw new ArgumentNullException("source");
  return list.Contains(source);
}

EDIT en réponse au commentaire ci-dessous: Si vous ne vous occupez que de chaînes, alors:

public static bool In(this string source, params string[] list)
{
    if (null == source) throw new ArgumentNullException("source");
    return list.Contains(source, StringComparer.OrdinalIgnoreCase);
}

Ce qui conduit à la syntaxe que vous connaissez bien:

if(x.In("A","B","C"))
{
  // do something....
}

Notez que c’est à peu près la même chose que tout le monde n’a posté que dans une syntaxe proche de celle que vous avez mentionnée.

8
Khepri
List<string> possibleMatches = new List<string>{"A", "B", "C"};
possibleMatches.Contains(inputString);
2
Victor Hurdugaci

Sûr

var lst = new List<string>() { "A", "B", "C" };
if (lst.Contains(x, StringComparer.OrdinalIgnoreCase) {
   // do something
}
1
Jimmy

Il y a plusieurs approches à cela, je vous suggérerais de faire quelque chose comme:

 private const string _searched = "A|B|C|";
 private void button1_Click(object sender, EventArgs e)
 {
     string search = "B" + "|";
     if (_searched.IndexOf(search) > -1)
     {
         //do something
     }
 }

Il y a beaucoup d'autres façons de gérer cela, et plus votre champ de recherche s'agrandit, plus il est probable que l'utilisation d'un tableau, d'une table de hachage ou d'une collection devient précieuse. Tant que votre champ de possibilités reste limité, l'utilisation d'une chaîne simple sera votre meilleure performance. Toute la surcharge de tableaux ou d'objets plus complexes (ou de tableaux d'objets ...) est inutile. 

0
Cos Callis