Comparaison de plusieurs chaînes avec C #

Disons que j'ai besoin de comparer si la chaîne x est "A", "B" ou "C".

Avec Python, je peux l'utiliser dans l'opérateur de vérifier 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 semblable à Python?

AJOUTÉ

J'ai besoin d'ajouter System.Linq afin d'utiliser la casse Contenir().

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

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

source d'informationauteur prosseek

c#string

Utilisation Énumérable.Contient<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
}

if ((new[]{"A","B","C"}).Contains(x, StringComparer.OrdinalIgnoreCase))

7

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

Une Façon D'Utiliser 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);
}
```
MODIFIER en réponse au commentaire ci-dessous:
Si vous êtes uniquement intéressé par les cordes puis:
```
public static bool In(this string source, params string[] list)
{
    if (null == source) throw new ArgumentNullException("source");
    return list.Contains(source, StringComparer.OrdinalIgnoreCase);
}
```
Qui conduit à la syntaxe que vous êtes familier avec:
```
if(x.In("A","B","C"))
{
  //do something....
}
```
Remarque, c'est à peu près exactement le même que tout le monde a publié uniquement dans une syntaxe plus proche de ce que vous avez mentionné.

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

Sûr

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

0

Probablement votre meilleur pari serait la Sélectionnez Cas (switch en C#) déclaration.

Edit: Désolé, Sélectionnez la case à cocher est VB.NET (ma langue d'habitude) et c'est le switch en C#.
0

Il ya un couple d'approches pour cela, je vous suggère 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 cette situation, et plus votre champ de recherche, plus ils sont enclins à l'aide d'un tableau, table de hachage ou de la collection devient précieuses. Tant que votre champ de possibilités reste faible, l'utilisation d'une simple chaîne va être votre meilleure performance. Tous les frais généraux de la plus complexe des tableaux ou des objets (ou des tableaux d'objets...) est inutile.

Vous devez vous connecter pour publier un commentaire.