Existe-t-il un opérateur de comparaison en C# comme l'instruction IN de SQL ?

Question

Il ne s'agit pas d'une question spécifique mais d'une question générique qui me trotte dans la tête depuis longtemps.

Je dois vérifier si une variable contient une valeur d'une liste de chaînes de caractères.

par exemple

status == "Open" || status =="Active" || status =="Reopen" || status = "InActive" etc..

En SQL, il est très facile d'écrire ce type d'instructions, par exemple

select * from ticket where status in ("Open", "Active", "Reopen", "InActive")

Je me demande si nous n'avons pas une déclaration aussi simple en C# ?

Quelqu'un connaît-il un moyen simple, comme SQL, d'écrire ce type d'instructions sans utiliser les types génériques de boucle if else, foreach ou LINQ, etc.

Je sais que LINQ existe mais ce n'est pas aussi simple que IN of sql.

Answer 1

tickets.Where(t => new[] {"Open",
                          "Active",
                          "Reopen",
                          "InActive"}.Any(x => x == t.status))

Vous pouvez également utiliser la méthode Contain au lieu de la méthode Any, mais utilisez la méthode Any si vous souhaitez mettre en œuvre une logique de comparaison, au lieu du comparateur d'égalité par défaut.

OU

Implémenter des extensions pour supporter la méthode IN :

public static class Extensions
{
    public static bool In<TItem>(this TItem source, Func<TItem, TItem, bool> comparer, IEnumerable<TItem> items)
    {
        return items.Any(item => comparer(source, item));
    }

    public static bool In<TItem, T>(this TItem source, Func<TItem, T> selector, IEnumerable<TItem> items)
    {
        return items.Select(selector).Contains(selector(source));
    }

    public static bool In<T>(this T source, IEnumerable<T> items)
    {
        return items.Contains(source);
    }

    public static bool In<TItem>(this TItem source, Func<TItem, TItem, bool> comparer, params TItem[] items)
    {
        return source.In(comparer, (IEnumerable<TItem>)items);
    }

    public static bool In<TItem, T>(this TItem source, Func<TItem, T> selector, params TItem[] items)
    {
        return source.In(selector, (IEnumerable<TItem>)items);
    }

    public static bool In<T>(this T source, params T[] items)
    {
        return source.In((IEnumerable<T>)items);
    }
}

Et utilisez comme ça :

bool b;

b = 7.In(3, 5, 6, 7, 8); // true
b = "hi".In("", "10", "hi", "Hello"); // true
b = "hi".In("", "10", "Hi", "Hello"); // false
b = "hi".In((s1, s2) => string.Equals(s1, s2, StringComparison.OrdinalIgnoreCase), "", "10", "Hi"); // true

var tuples = new List<Tuple<int, string>>();

for (var i = 0; i < 10; i++)
{
    tuples.Add(Tuple.Create(i, ""));
}

var tuple = Tuple.Create(3, "");

b = tuple.In(tup => tup.Item1, tuples); // true

Answer 2

(new [] { "Open", "Active", "Reopen", "InActive" }).Contains(status)

Answer 3

Cela fonctionne pour moi.

(new List<string>{ "Open", "Active", "Reopen", "InActive" }).Contains("status");

J'aime aussi la fonctionnalité de C# 3.0 qui permet de créer une extension de la classe String.

public static class StringExtensions
{
    public static bool In(this string @this, params string[] strings)
    {
        return strings.Contains(@this); 
    }
}

et plus tard, nous pourrons l'utiliser de la manière la plus simple qui soit.

status.Contains("Open", "Active", "Reopen", "InActive");

C'est génial si vous devez écrire de nombreuses déclarations comme celle-ci. Je préfère écrire cette extension si j'écris de l'ancien style pour au moins 5-10 déclarations dans 2 fichiers ou plus.