Requête Linq un tableau de chaînes en c# si contient l'une des deux valeurs?

J'ai un tableau de chaînes 

string[] tmp = foo();

Si AUCUNE des chaînes de foo contenir "bar" ou "baz" je veux exécuter un code.
Est-ce la bonne façon d'interroger cet objet?

if(!tmp.Any(p => p.ToLower().Contains("bar") || p.ToLower().Contains("baz"))
 doSomething();

L' || semble idiot. Dois-je utiliser une expression régulière ici, ou est-il une meilleure façon de faire cela? ***Notez également les valeurs dans tmp sont comme "bar=someValue" comme une chaîne de requête. Ce code fonctionne bien, mais je suis certain qu'il peut mieux écrit. Merci pour les conseils de commentaires.

Pourquoi le || sembler idiot? Vous voulez faire quelque chose si X ou Y est vrai pour n'importe quel élément. Semble tout à fait raisonnable pour moi.
Pour moi, vous le code est parfaitement correct. Si il ya de nombreux éléments, je voudrais créer une extension de la méthode à simplifier la syntaxe. Pour jusqu'à 2/3 points que je voudrais aller avec cette approche.
Oui Jon || est ok maintenant, mais qu'en est quand j'ai besoin de regarder pour plus de valeurs à côté de la barre ou de baz? Je cherchais quelque chose qui évolue un peu mieux. J'ai comme l'intersection des approches, mais les valeurs dans tmp sont en nom=valeur de format. Merci!
consultez la mise à jour de réponse
Ce n'est pas exactement la réponse à votre question, mais il est effectivement plus rapide à utiliser p.IndexOf("bar", StringComparison.CurrentCultureIgnoreCase) < 0 et d'éviter la ToLower() appel.

OriginalL'auteur Hcabnettek | 2012-11-14

  1. 4

    Mieux? Je ne sais pas, mais devrait fonctionner.

    if(!tmp.Select(x => x.Split('=')[0])
                    .Intersect(new[] { "foo", "baz" }, 
                               StringComparer.InvariantCultureIgnoreCase).Any())
    doSomething();
    Je ne suis pas downvoter, mais je vois des cas de match manquantes
    mais il dit aussi que les chaînes sont en forme de "barre=someValue".
    c'est pourquoi se croisent ne fonctionnera pas.
    oui le code fonctionne, il semble tout à fait inefficace est tout. Je pensais à cela, peut-être? !tmp.Tout(p => Regex.IsMatch(p, @"^(foo|baz)")
    L'existant semble au moins plus élégant.

    OriginalL'auteur L.B

  2. 1

    Vous pouvez imbriquer Any avec StringComparison surcharge de IndexOf:

    string[] source = { "hi=there", "hello=world", "foo=bar" };
string[] exclude = { "baz", "bar" };

if (!source.Any(src => 
        exclude.Any(exl =>  
            src.IndexOf(exl, StringComparison.InvariantCultureIgnoreCase) >= 0))) 
    doSomething();

    Ou emballés comme une extension de la méthode:

    public static class StringExtensions {
    public static bool ContainsAny(
        this IEnumerable<string> source,
        IEnumerable<string> target,
        StringComparison comparisonType = StringComparison.InvariantCultureIgnoreCase) {
        return source.Any(xsource => target.Any(
                xtarget => xsource.IndexOf(xtarget, comparisonType) >= 0));
    }
}


//Later ...
if (!source.ContainsAny(exclude))
    doSomething();

    OriginalL'auteur Joshua Honig

  3. 0

    Je ne pense pas qu'il y est quelque chose de mal avec votre code existant, bien qu'il pourrait être légèrement modifié de façon à éviter un supplément de ToLower() appel:

    var exists = tmp.Any(p => 
{ 
    var s = p.ToLower(); 
    return s.Contains("bar") || s.Contains("baz");
});
if(!exists) doSomething();

    Si vos termes de recherche peuvent être nombreuses, quelque chose comme ça pourrait fonctionner mieux:

    var terms = new string[] {"bar", "baz", "foo", "boo", ...};
var exists = tmp.Any(p => terms.Any(t => p.ToLower().Contains(t)));
if(!exists) doSomething();

    OriginalL'auteur Eren Ersönmez