Combiner Plusieurs Prédicats

Est-il possible en c# .NET 2.0! pour combiner plusieurs Prédicats?

Disons que j'ai le code suivant.

List<string> names = new List<string>();
names.Add("Jacob");
names.Add("Emma");
names.Add("Michael");
names.Add("Isabella");
names.Add("Ethan");
names.Add("Emily");

List<string> filteredNames = names.FindAll(StartsWithE);

static bool StartsWithE(string s)
{
    if (s.StartsWith("E"))
    {
        return true;
    }
    else
    {
        return false;
    }
}

Cela me donne:

Emma
Ethan
Emily

Donc c'est plutôt cool, mais je sais voulez être en mesure de filtrer à l'aide de plusieurs prédicats.

Donc, je veux être en mesure de dire quelque chose comme ceci:

List<string> filteredNames = names.FindAll(StartsWithE OR StartsWithI);

Afin d'obtenir:

Emma
Isabella
Ethan
Emily

Comment puis-je y parvenir?
Actuellement, je suis juste filtrage de la liste complète deux fois et en combinant les résultats par la suite. Mais, malheureusement, c'est tout à fait inefficent et plus important encore, je perds l'ordre de tri d'origine, ce qui n'est pas acceptable dans ma situation.

J'ai aussi besoin d'être en mesure d'effectuer une itération sur un nombre illimité de filtres/prédicats comme il peut être tout à fait un lot.

Encore, il doit être un .NET 2.0 solution malheureusement je ne peux pas utiliser une version plus récente du cadre

Merci beaucoup.

InformationsquelleAutor eric | 2009-08-08
  1. 55

    Comment sur:

    public static Predicate<T> Or<T>(params Predicate<T>[] predicates)
{
    return delegate (T item)
    {
        foreach (Predicate<T> predicate in predicates)
        {
            if (predicate(item))
            {
                return true;
            }
        }
        return false;
    };
}

    Et complet:

    public static Predicate<T> And<T>(params Predicate<T>[] predicates)
{
    return delegate (T item)
    {
        foreach (Predicate<T> predicate in predicates)
        {
            if (!predicate(item))
            {
                return false;
            }
        }
        return true;
    };
}

    Puis l'appeler avec:

    List<string> filteredNames = names.FindAll(Helpers.Or(StartsWithE, StartsWithI));

    Une autre alternative serait d'utiliser la multidiffusion délégués et ensuite les partager à l'aide de GetInvocationList(), puis faire la même chose. Alors que vous pourriez faire:

    List<string> filteredNames = names.FindAll(Helpers.Or(StartsWithE+StartsWithI));

    Je ne suis pas un grand fan de la dernière approche, bien qu'il se sent comme un peu un abus de la multidiffusion.

    • Merci! Fonctionne parfaitement!
    • Très Pratique. Besoin plusieurs prédicats d'un filtre à ICollectionView.
    • L'ensemble de la fonction peut être raccourcie à return item => predicates.All(predicate => predicate(item));
    • Assurez-vous - si vous êtes à l'aide de LINQ. Notez que la question nécessaire .NET 2.0. (Ils auraient pu utiliser des expressions lambda, mais nous ne savions pas quelle version de VS l'OP était de l'utiliser.)
    InformationsquelleAutor Jon Skeet
  2. 29

    Je suppose que vous pourriez écrire quelque chose comme ceci:

    Func<string, bool> predicate1 = s => s.StartsWith("E");
Func<string, bool> predicate2 = s => s.StartsWith("I");
Func<string, bool> combinedOr = s => (predicate1(s) || predicate2(s));
Func<string, bool> combinedAnd = s => (predicate1(s) && predicate2(s));

    ... et ainsi de suite.

    • Solution sympa 🙂
    • n'avez-vous pas besoin d'invoquer le prédicat Funcs dans le combiné Funcs?
    InformationsquelleAutor Andrey Ilnitsky
  3. 5

    Je viens récemment est venu avec une solution à ce problème, qui pourrait également être utile. J'ai développé la méthode FindAll pour les listes, ce qui me permet d'empiler des prédicats dans les listes que j'avais besoin:

    public static class ExtensionMethods
{
    public static List<T> FindAll<T> (this List<T> list, List<Predicate<T>> predicates)
    {
        List<T> L = new List<T> ();
        foreach (T item in list)
        {
            bool pass = true;
            foreach (Predicate<T> p in predicates)
            {
                if (!(p (item)))
                {
                    pass = false;
                    break;
                }
            }
            if (pass) L.Add (item);
        }
        return L;
    }
}

    Elle renvoie une liste des éléments correspondant à tous les prédicats. Bien sûr, il peut facilement être modifié OU tous les prédicats au lieu de ET. Mais avec ce seul on peut assembler tout à fait une bonne variété de combinaisons logiques.

    Utilisation:

    {
    List<Predicate<int>> P = new List<Predicate<int>> ();
    P.Add (j => j > 100);
    P.Add (j => j % 5 == 0 || j % 7 == 0);
    P.Add (j => j < 1000);

    List<int> L = new List<int> () { 0, 1, 2, ... 999, 1000 }
    List<int> result = L.FindAll (P);

    //result will contain: 105, 110, 112, 115, 119, 120, ... 994, 995 
}
    • Votre code a un bug. La première pause encore les résultats dans l'élément s'ajouter à la liste...même si un prédicat a retourné false.
    • Vous avez raison, c'est corrigé maintenant. Merci pour m'aviser!
    InformationsquelleAutor Battle
  4. 1

    Dans .NET 2.0, il y a des délégués anonymes dont vous pourrez bénéficier de:

    List<string> filteredNames = names.FindAll(
   delegate(string s) { return StartsWithE(s) OR StartsWithI(s); }
);

    En fait, vous pouvez l'utiliser pour remplacer vos fonctions ainsi:

    List<string> filteredNames = names.FindAll(
   delegate(string s) { return s.StartsWith("E") || s.StartsWith("I"); }
);
    InformationsquelleAutor Pavel Minaev
  5. 0

    Vous pouvez créer une troisième prédicat en interne Rup les résultats ensemble. Je pense que vous pouvez le faire à la volée à l'aide d'une expression lambda. Quelque chose comme ceci(ce n'est pas une expression lambda que je ne suis pas trop bonne avec que snytax):

    static bool StartsWithEorI(string s)
{
    return StartsWithE(s) || StartsWithI(s);
}
    • Sûr que je le pouvais, mais comme dans cet exemple, il existe un grand nombre de combinaisons. même pas penser à la combinaison de trois filtres... Aussi encore une fois, malheureusement, je peux l'utiliser SEUL .NET 2.0
    • Ah c'est dommage. Je suis sûr que si vous aviez anonyme des délégués ou des expressions lambda, il vous donnerait que "à la volée" en combinant la puissance que vous souhaitez.
    InformationsquelleAutor AaronLS
  6. 0

    Vous pouvez rassembler le prédicat de la méthode dans une classe et ont le constructeur accepte un tableau de chaînes de caractères à tester:

    class StartsWithPredicate
{
    private string[] _startStrings;
    public StartsWithPredicate(params string[] startStrings)
    {
        _startStrings = startStrings;
    }
    public bool StartsWith(string s)
    {
        foreach (var test in _startStrings)
        {
            if (s.StartsWith(test))
            {
                return true;
            }
        }
        return false;
    }
}

    Alors vous pouvez faire un appel comme ceci:

    List<string> filtered = names.FindAll((new StartsWithPredicate("E", "I")).StartsWith);

    De cette façon, vous pouvez tester n'importe quelle combinaison de chaînes d'entrée sans avoir à étendre le code de base avec de nouvelles variations de la StartsWith méthode.

    InformationsquelleAutor Fredrik Mörk
  7. 0

    Avoir utilisé ce modèle largement avec le ci-dessus 'params' méthode de la baie, j'ai été intrigué par récemment à l'apprentissage sur le délégué Multicast. Depuis délégués intrinsèquement charge une liste (ou multicast), vous pouvez ignorer les params[] modèle et il suffit de fournir un seul délégué à la fonction Test (). Vous aurez besoin de faire appel GetInvokationList fourni sur le Prédicat<>. Voir ceci: Délégué Multicast de type Func (avec une valeur de retour)?

    InformationsquelleAutor Brian Broussard