web-dev-qa-db-fra.com

Prédicats Délégués en C #

Pouvez vous m'expliquer:

  • Qu'est-ce qu'un délégué de prédicat?
  • Où devrions-nous utiliser des prédicats?
  • Des meilleures pratiques lors de l'utilisation de prédicats?

Un code source descriptif sera apprécié.

c#.netpredicate
246
Canavar

Un prédicat est une fonction qui renvoie true ou false. Un délégué de prédicat est une référence à un prédicat.

Donc, fondamentalement, un délégué de prédicat est une référence à une fonction qui renvoie true ou false. Les prédicats sont très utiles pour filtrer une liste de valeurs - voici un exemple. 

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> list = new List<int> { 1, 2, 3 };

        Predicate<int> predicate = new Predicate<int>(greaterThanTwo);

        List<int> newList = list.FindAll(predicate);
    }

    static bool greaterThanTwo(int arg)
    {
        return arg > 2;
    }
}

Maintenant, si vous utilisez C # 3, vous pouvez utiliser un lambda pour représenter le prédicat de manière plus propre:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> list = new List<int> { 1, 2, 3 };

        List<int> newList = list.FindAll(i => i > 2);
    }
}
312
Andrew Hare

En guise de réponse à la réponse d'Andrew concernant les c # 2 et c # 3 ... vous pouvez également les effectuer en ligne pour une fonction de recherche unique (voir ci-dessous).

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> list = new List<int> { 1, 2, 3 };

        List<int> newList = list.FindAll(delegate(int arg)
                           {
                               return arg> 2;
                           });
    }
}

J'espère que cela t'aides.

81
WestDiscGolf

Juste un délégué qui retourne un booléen. Il est beaucoup utilisé dans les listes de filtrage, mais peut être utilisé où vous le souhaitez.

List<DateRangeClass>  myList = new List<DateRangeClass<GetSomeDateRangeArrayToPopulate);
myList.FindAll(x => (x.StartTime <= minDateToReturn && x.EndTime >= maxDateToReturn):
11
Adam Carr

Il y a un bon article sur les prédicats ici , bien qu'il soit de l'ère .NET2, il n'y a donc aucune mention d'expressions lambda.

8
LukeH

Qu'est-ce que le prédicat délégué?

1) Le prédicat est une fonctionnalité qui renvoie true ou false. Ce concept est entré dans le framework .net 2.0. 2) Il est utilisé avec l'expression lambda (=>). Il prend le type générique en tant qu’argument . 3) Il permet de définir une fonction de prédicat et de le passer en paramètre à une autre fonction . 4) C’est un cas particulier de Func, dans lequel il ne prend qu'un seul paramètre et retourne toujours un bool.

Dans l'espace de noms C #:

namespace System
{   
    public delegate bool Predicate<in T>(T obj);
}

Il est défini dans l'espace de noms System.

Où devrions-nous utiliser Predicate Delegate?

Nous devrions utiliser Predicate Delegate dans les cas suivants:

1) Pour rechercher des éléments dans une collection générique . par exemple. 

var employeeDetails = employees.Where(o=>o.employeeId == 1237).FirstOrDefault();

2) Exemple de base qui raccourcit le code et renvoie true ou false:

Predicate<int> isValueOne = x => x == 1;

maintenant, appelez le prédicat ci-dessus:

Console.WriteLine(isValueOne.Invoke(1)); // -- returns true.

3) Une méthode anonyme peut également être affectée à un type de délégué prédicat comme ci-dessous:

Predicate<string> isUpper = delegate(string s) { return s.Equals(s.ToUpper());};
    bool result = isUpper("Hello Chap!!");

Toutes les meilleures pratiques sur les prédicats?

Utilisez Func, les expressions Lambda et les délégués au lieu de prédicats.

6
Gul Md Ershad

Les méthodes de recherche basées sur les prédicats permettent à un délégué de méthode ou à une expression lambda de décider si un élément donné est une «correspondance» Un prédicat est simplement un délégué qui accepte un objet et renvoie true ou false: Public delegate bool Predicate (objet T);

   static void Main()
        {
            string[] names = { "Lukasz", "Darek", "Milosz" };
            string match1 = Array.Find(names, delegate(string name) { return name.Contains("L"); });
            //or
            string match2 = Array.Find(names, delegate(string name) { return name.Contains("L"); });
            //or
            string match3 = Array.Find(names, x => x.Contains("L"));


            Console.WriteLine(match1 + " " + match2 + " " + match3);     // Lukasz Lukasz Lukasz
        }
        static bool ContainsL(string name) { return name.Contains("L"); }
5
lukaszk

Si vous êtes dans VB 9 (VS2008), un prédicat peut être une fonction complexe:

Dim list As New List(Of Integer)(New Integer() {1, 2, 3})
Dim newList = list.FindAll(AddressOf GreaterThanTwo)
...
Function GreaterThanTwo(ByVal item As Integer) As Boolean
    'do some work'
    Return item > 2
End Function

Ou vous pouvez écrire votre prédicat sous la forme d'un lambda, à condition qu'il ne s'agisse que d'une expression:

Dim list As New List(Of Integer)(New Integer() {1, 2, 3})
Dim newList = list.FindAll(Function(item) item > 2)
2
danlash

Le prédicat tombe dans la catégorie des délégués génériques en C #. Ceci est appelé avec un argument et retourne toujours le type booléen. Fondamentalement, le prédicat est utilisé pour tester la condition - vrai/faux. De nombreuses classes prennent en charge les prédicats en tant qu'argument. Par exemple list.findall attend le prédicat de paramètre. Voici un exemple de prédicat.

Imaginez un pointeur de fonction avec la signature - 

délégué bool myDelegate (match T);

Voici l'exemple

Node.cs 

namespace PredicateExample
{
    class Node
    {
        public string Ip_Address { get; set; }
        public string Node_Name { get; set; }
        public uint Node_Area { get; set; }
    }
}

Classe principale - 

using System;
using System.Threading;
using System.Collections.Generic;

namespace PredicateExample
{
    class Program
    {
        static void Main(string[] args)
        {
            Predicate<Node> backboneArea = Node =>  Node.Node_Area == 0 ;
            List<Node> Nodes = new List<Node>();
            Nodes.Add(new Node { Ip_Address = "1.1.1.1", Node_Area = 0, Node_Name = "Node1" });
            Nodes.Add(new Node { Ip_Address = "2.2.2.2", Node_Area = 1, Node_Name = "Node2" });
            Nodes.Add(new Node { Ip_Address = "3.3.3.3", Node_Area = 2, Node_Name = "Node3" });
            Nodes.Add(new Node { Ip_Address = "4.4.4.4", Node_Area = 0, Node_Name = "Node4" });
            Nodes.Add(new Node { Ip_Address = "5.5.5.5", Node_Area = 1, Node_Name = "Node5" });
            Nodes.Add(new Node { Ip_Address = "6.6.6.6", Node_Area = 0, Node_Name = "Node6" });
            Nodes.Add(new Node { Ip_Address = "7.7.7.7", Node_Area = 2, Node_Name = "Node7" });

            foreach( var item in Nodes.FindAll(backboneArea))
            {
                Console.WriteLine("Node Name " + item.Node_Name + " Node IP Address " + item.Ip_Address);
            }

            Console.ReadLine();
        }
    }
}
0
dexterous_stranger