Delegados predicados em C #

Você pode me explicar:

• O que é um Delegado Predicado?
• Onde devemos usar predicados?
• Alguma prática recomendada ao usar predicados?

O código-fonte descritivo será apreciado.

Um predicado é uma função que retorna trueou false. Um delegado de predicado é uma referência a um predicado.

Então, basicamente, um delegado predicado é uma referência a uma função que retorna trueor false. Predicados são muito úteis para filtrar uma lista de valores - aqui está um exemplo.

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

Agora, se você estiver usando o C # 3, poderá usar um lambda para representar o predicado de uma maneira mais limpa:

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

Seguindo a resposta de Andrew em relação a c # 2 e c # 3 ... você também pode fazê-las em linha para uma função de pesquisa única (veja abaixo).

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

Espero que isto ajude.

Apenas um delegado que retorna um booleano. É muito usado em listas de filtragem, mas pode ser usado onde você quiser.

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

Há um bom artigo sobre predicados aqui , embora seja da era .NET2, então não há menção de expressões lambda lá.

O que é delegado predicado?

1) Predicado é um recurso que retorna verdadeiro ou falso. Este conceito veio na estrutura .net 2.0. 2) Está sendo usado com a expressão lambda (=>). É preciso um tipo genérico como argumento. 3) Permite que uma função predicada seja definida e passada como parâmetro para outra função. 4) É um caso especial de a Func, na medida em que leva apenas um único parâmetro e sempre retorna um bool.

No espaço de nome C #:

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

É definido no espaço para nome do sistema.

Onde devemos usar o delegado predicado?

Devemos usar o delegado predicado nos seguintes casos:

1) Para pesquisar itens em uma coleção genérica. por exemplo

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

2) Exemplo básico que reduz o código e retorna verdadeiro ou falso:

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

agora, Ligue acima do predicado:

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

3) Um método anônimo também pode ser atribuído a um tipo de delegado do Predicado, conforme abaixo:

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

Alguma prática recomendada sobre predicados?

Use Func, expressões lambda e delegados em vez de predicados.

Os métodos de pesquisa baseados em predicado permitem que um delegado de método ou expressão lambda decida se um determinado elemento é uma "correspondência". Um predicado é simplesmente um delegado aceitando um objeto e retornando verdadeiro ou falso: public delegate bool Predicate (objeto 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 você estiver no VB 9 (VS2008), um predicado pode ser uma função complexa:

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 você pode escrever seu predicado como um lambda, desde que seja apenas uma expressão:

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

Predicado cai na categoria de delegados genéricos em C #. Isso é chamado com um argumento e sempre retorna o tipo booleano. Basicamente, o predicado é usado para testar a condição - verdadeiro / falso. Muitas classes suportam predicado como argumento. Por exemplo, list.findall espera o predicado do parâmetro. Aqui está um exemplo do predicado.

Imagine um ponteiro de função com a assinatura -

delegado bool myDelegate (correspondência T);

Aqui está o exemplo

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 principal -

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

Simplesmente -> eles fornecem valores Verdadeiro / Falso com base na condição usada principalmente para consulta. usado principalmente com delegados

considere exemplo de lista

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

contém nomes e idades. Agora diga que queremos encontrar nomes na condição. Então, eu usarei,

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

tentou mantê-lo simples!

Um delegado define um tipo de referência que pode ser usado para encapsular um método com uma assinatura específica. Ciclo de vida do delegado de C #: O ciclo de vida do delegado de C # é

• Declaração
• Instanciação
• EM FÉRIAS

saiba mais formulário http://asp-net-by-parijat.blogspot.in/2015/08/what-is-delegates-in-c-how-to-declare.html