Delegati Predicati in C #

Mi spieghi:

• Che cos'è un delegato delegato?
• Dove dovremmo usare i predicati?
• Qualche best practice durante l'utilizzo dei predicati?

Sarà apprezzato il codice sorgente descrittivo.

Un predicato è una funzione che restituisce trueo false. Un delegato predicato è un riferimento a un predicato.

Quindi in pratica un delegato predicato è un riferimento a una funzione che restituisce trueo false. I predicati sono molto utili per filtrare un elenco di valori: ecco un esempio.

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

Ora se stai usando C # 3 puoi usare un lambda per rappresentare il predicato in modo più pulito:

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

Partendo dalla risposta di Andrew per quanto riguarda c # 2 e c # 3 ... puoi anche farli in linea per una funzione di ricerca una tantum (vedi sotto).

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

Spero che questo ti aiuti.

Solo un delegato che restituisce un valore booleano. È molto utilizzato negli elenchi di filtri, ma può essere utilizzato ovunque tu voglia.

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

C'è un buon articolo sui predicati qui , anche se è dell'era .NET2, quindi non si fa menzione delle espressioni lambda.

Che cos'è il delegato delegato?

1) Predicate è una funzionalità che restituisce vero o falso. Questo concetto è entrato nel framework .net 2.0. 2) Viene utilizzato con l'espressione lambda (=>). Prende il tipo generico come argomento. 3) Consente di definire una funzione predicato e di passarla come parametro a un'altra funzione. 4) È un caso speciale di a Func, in quanto accetta solo un singolo parametro e restituisce sempre un valore bool.

Nello spazio dei nomi C #:

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

È definito nello spazio dei nomi di sistema.

Dove dovremmo usare il delegato predicato?

Dovremmo usare il delegato delegato nei seguenti casi:

1) Per cercare oggetti in una raccolta generica. per esempio

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

2) Esempio di base che accorcia il codice e restituisce vero o falso:

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

ora, chiama sopra predicato:

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

3) Un metodo anonimo può anche essere assegnato a un tipo di delegato Predicato come di seguito:

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

Qualche best practice sui predicati?

Usa Func, Lambda Expressions e Delegate invece di Predicate.

I metodi di ricerca basati su predicato consentono a un delegato di metodo o un'espressione lambda di decidere se un determinato elemento è una "corrispondenza". Un predicato è semplicemente un delegato che accetta un oggetto e restituisce vero o falso: public delegate bool Predicate (oggetto 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"); }

Se ti trovi in ​​VB 9 (VS2008), un predicato può essere una funzione complessa:

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

Oppure puoi scrivere il tuo predicato come lambda, purché sia ​​solo un'espressione:

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

Il predicato rientra nella categoria dei delegati generici in C #. Questo viene chiamato con un argomento e restituisce sempre il tipo booleano. Fondamentalmente, il predicato viene usato per testare la condizione - vero / falso. Molte classi supportano il predicato come argomento. Ad esempio list.findall si aspetta il predicato del parametro. Ecco un esempio del predicato.

Immagina un puntatore a funzione con la firma -

bool delegate myDelegate (corrispondenza T);

Ecco l'esempio

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

Semplicemente -> forniscono valori Vero / Falso in base alla condizione utilizzata principalmente per l'interrogazione. usato principalmente con i delegati

prendere in considerazione un esempio di elenco

List<Program> blabla= new List<Program>();
        blabla.Add(new Program("shubham", 1));
        blabla.Add(new Program("google", 3));
        blabla.Add(new Program("world",5));
        blabla.Add(new Program("hello", 5));
        blabla.Add(new Program("bye", 2));

contiene nomi ed età. Ora dì che vogliamo trovare i nomi a condizione, quindi userò,

    Predicate<Program> test = delegate (Program p) { return p.age > 3; };
        List<Program> matches = blabla.FindAll(test);
        Action<Program> print = Console.WriteLine;
        matches.ForEach(print);

ho provato a mantenerlo semplice!

Un delegato definisce un tipo di riferimento che può essere utilizzato per incapsulare un metodo con una firma specifica. Ciclo di vita del delegato C #: il ciclo di vita del delegato C # è

• Dichiarazione
• la creazione di istanze
• IN VACANZA

ulteriori informazioni http://asp-net-by-parijat.blogspot.in/2015/08/what-is-delegates-in-c-how-to-declare.html