generic - Delegados Predicados en C#

how to use func c#

Question

Me puedes explicar;

• ¿Qué es un delegado predicado?
• ¿Dónde debemos usar los predicados?
• ¿Alguna de las mejores prácticas al usar predicados?

Se apreciará el código fuente descriptivo,

Gracias por todas las respuestas!

Answer 1

A partir de la respuesta de Andrew con respecto a c # 2 y c # 3 ... también puede hacerlas en línea para una función de búsqueda única (ver más abajo).

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 esto ayude.

Answer 2

El predicado es una construcción funcional que proporciona una manera conveniente de probar básicamente si algo es cierto de un objeto T dado.

Por ejemplo, supongamos que tengo una clase:

    class Person {
          public string Name { get; set; }
          public int Age { get; set; }
         }

Ahora digamos que tengo una lista de personas y quiero saber si hay alguien llamado Oscar en la lista.

Sin usar un Predicado (o Linq, o cualquiera de esas cosas de fantasía), siempre podría lograr esto haciendo lo siguiente:

    Person oscar = null;
    foreach (Person person in people) {
      if (person.Name == "Oscar") {
      oscar = person;
      break;
    }
  }

 if (oscar != null) {
 // Oscar exists!
}

Esto está bien, pero luego digamos que quiero verificar si hay una persona llamada "Ruth". ¿O una persona cuya edad es 17?

Usando un Predicado, puedo encontrar estas cosas usando un MUCHO menos código:

Predicate<Person> oscarFinder = (Person p) => { return p.Name == "Oscar"; };
Predicate<Person> ruthFinder = (Person p) => { return p.Name == "Ruth"; };
Predicate<Person> seventeenYearOldFinder = (Person p) => { return p.Age == 
17; };

Person oscar = people.Find(oscarFinder);
Person ruth = people.Find(ruthFinder);
Person seventeenYearOld = people.Find(seventeenYearOldFinder);

Note que dije mucho menos código, no mucho más rápido. La idea errónea que tienen los desarrolladores es que si algo toma una línea, debe funcionar mejor que algo que toma diez líneas. Pero detrás de escena, el método Find, que requiere un Predicado, simplemente se enumera después de todo. Lo mismo es cierto para muchas de las funcionalidades de Linq.

Así que echemos un vistazo al código específico en su pregunta:

Predicate<int> pre = delegate(int a){ return a % 2 == 0; };

Aquí tenemos un pre predicado que toma un int a y devuelve un% 2 == 0.

Esto es esencialmente la prueba de un número par. Lo que eso significa es:

pre(1) == false;
pre(2) == true;

Y así. Esto también significa que, si tiene una lista de entradas y desea encontrar el primer número par, puede hacer esto:

int firstEven = ints.Find(pre);

Por supuesto, como con cualquier otro tipo que pueda usar en el código, es una buena idea dar nombres descriptivos a sus variables; así que aconsejaría cambiar el pre anterior a algo como evenFinder o isven, algo en ese sentido. Entonces el código anterior es mucho más claro:

int firstEven = ints.Find(evenFinder);

Answer 3

Hay un buen artículo sobre predicados here , aunque es de la era .NET2, por lo que no hay ninguna mención de las expresiones lambda allí.

Answer 4

Los métodos de búsqueda basados ​​en predicados permiten que un delegado de método o una expresión lambda decidan si un elemento dado es una "coincidencia". Un predicado es simplemente un delegado que acepta un objeto y devuelve verdadero o 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"); }

Answer 5

Sólo un delegado que devuelve un booleano. Se usa mucho en las listas de filtrado, pero se puede usar donde quieras.

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

Answer 6

Si está en VB 9 (VS2008), un predicado puede ser una función compleja:

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

O puedes escribir tu predicado como un lambda, siempre que sea una sola expresión:

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

Answer 7

Un delegado define un tipo de referencia que se puede usar para encapsular un método con una firma específica. C # delegado Ciclo de vida: el ciclo de vida de C # delegado es

• Declaración
• Instanciación
• EN VACACIONES

Obtenga más información en http://asp-net-by-parijat.blogspot.in/2015/08/what-is-delegates-in-c-how-to-declare.html

Answer 8

¿Qué es el delegado de predicado?

1) Predicado es una característica que devuelve verdadero o falso. Este concepto ha venido en el marco .net 2.0. 2) Se está utilizando con la expresión lambda (=>). Toma el tipo genérico como argumento. 3) Permite definir una función de predicado y pasarla como parámetro a otra función. 4) Es un caso especial de un Func , ya que toma solo un único parámetro y siempre devuelve un bool.

En el espacio de nombres C #:

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

Se define en el espacio de nombres del sistema.

¿Dónde debemos usar Delegado Predicado?

Deberíamos usar Delegado Predicado en los siguientes casos:

1) Para buscar elementos en una colección genérica. p.ej

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

2) Ejemplo básico que acorta el código y devuelve verdadero o falso:

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

ahora, llame al predicado anterior:

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

3) Un método anónimo también se puede asignar a un tipo de delegado Predicado como se muestra a continuación:

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

¿Buenas prácticas sobre predicados?

Use Func, expresiones Lambda y delegados en lugar de predicados.

Answer 9

Un predicado es una función que devuelve true o false . Un delegado de predicado es una referencia a un predicado.

Entonces, básicamente, un delegado de predicado es una referencia a una función que devuelve true o false . Los predicados son muy útiles para filtrar una lista de valores, aquí hay un ejemplo.

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

Ahora, si está utilizando C # 3, puede usar un lambda para representar el predicado de una manera más limpia:

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