with Prädikat Delegaten in C#




tutorialspoint c# delegate (8)

Ein Delegat definiert einen Referenztyp, mit dem eine Methode mit einer bestimmten Signatur gekapselt werden kann. C # delegierter Lebenszyklus: Der Lebenszyklus von C # -Delegaten ist

  • Erklärung
  • Instanziierung
  • IM URLAUB

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

Kannst du mir erklären;

  • Was ist ein Predicate Delegate?
  • Wo sollten wir Prädikate verwenden?
  • Best Practices bei der Verwendung von Prädikaten?

Beschreibender Quellcode wird geschätzt,

Danke für alle Antworten!


Was ist Predicate Delegate?

1) Prädikat ist eine Funktion, die wahr oder falsch zurückgibt. Dieses Konzept ist in .net 2.0 Framework gekommen. 2) Es wird mit Lambda-Ausdruck (=>) verwendet. Es nimmt den generischen Typ als Argument an. 3) Es erlaubt eine Prädikatfunktion zu definieren und als Parameter an eine andere Funktion zu übergeben. 4) Es ist ein Spezialfall eines Func , da er nur einen einzigen Parameter benötigt und immer einen Func zurückgibt.

Im C # -Namespace:

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

Es ist im System-Namespace definiert.

Wo sollten wir Predicate Delegate verwenden?

Wir sollten Predicate Delegate in den folgenden Fällen verwenden:

1) Zum Suchen von Objekten in einer generischen Sammlung. z.B

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

2) Grundlegendes Beispiel, das den Code verkürzt und wahr oder falsch zurückgibt:

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

Rufen Sie jetzt das obige Prädikat auf:

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

3) Eine anonyme Methode kann auch einem Predicate-Delegattyp wie folgt zugewiesen werden:

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

Best Practices zu Prädikaten?

Verwenden Sie Func, Lambda Expressions und Delegates anstelle von Prädikaten.


Es gibt hier einen guten Artikel über Prädikate, obwohl es aus der .NET2-Ära stammt, also werden darin keine Lambda-Ausdrücke erwähnt.


Prädikat ist ein funktionales Konstrukt, das eine bequeme Möglichkeit bietet, grundsätzlich zu testen, ob etwas für ein gegebenes T-Objekt wahr ist.

Angenommen, ich habe eine Klasse:

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

Jetzt sagen wir, ich habe eine Liste Leute und ich möchte wissen, ob jemand namens Oscar in der Liste ist.

Ohne ein Prädikat (oder Linq oder irgendeines dieser ausgefallenen Dinge) zu verwenden, könnte ich dies immer erreichen, indem ich Folgendes tue:

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

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

Das ist in Ordnung, aber dann lass uns sagen, ich möchte überprüfen, ob es eine Person namens "Ruth" gibt? Oder eine Person, deren Alter 17 ist?

Mit einem Prädikat kann ich diese Dinge mit viel weniger Code finden:

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

Beachten Sie, dass ich viel weniger Code gesagt habe, nicht viel schneller. Ein gängiges Missverständnis von Entwicklern ist, dass, wenn etwas eine Zeile benötigt, es besser abschneiden muss als etwas, das zehn Zeilen benötigt. Aber hinter den Kulissen zählt die Find-Methode, die ein Prädikat verwendet, nur auf. Das gleiche gilt für viele Funktionen von Linq.

Sehen wir uns den spezifischen Code in Ihrer Frage an:

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

Hier haben wir ein Prädikat pre, das ein int a nimmt und ein% 2 == 0 zurückgibt.

Dies testet im Wesentlichen auf eine gerade Zahl. Was das bedeutet ist:

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

Und so weiter. Das bedeutet auch, wenn Sie eine List ints haben und die erste gerade Zahl suchen möchten, können Sie das tun:

int firstEven = ints.Find(pre);

Wie bei jedem anderen Typ, den Sie im Code verwenden können, sollten Sie Ihren Variablen natürlich aussagekräftige Namen geben. also würde ich raten, das obige Pre in etwas wie evenFinder oder isEven zu ändern - etwas in dieser Richtung. Dann ist der obige Code viel klarer:

int firstEven = ints.Find(evenFinder);

Wenn Sie in VB 9 (VS2008) sind, kann ein Prädikat eine komplexe Funktion sein:

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

Oder Sie können Ihr Prädikat als Lambda schreiben, solange es nur einen Ausdruck gibt:

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

Die Prädikat-basierten Suchmethoden ermöglichen es einem Methodendelegaten oder Lambda-Ausdruck zu entscheiden, ob ein bestimmtes Element eine "Übereinstimmung" ist. Ein Prädikat ist einfach ein Delegat, der ein Objekt annimmt und wahr oder falsch zurückgibt: public delegate bool Prädikat (T-Objekt);

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

Ausgehend von Andrews Antwort in Bezug auf c # 2 und c # 3 ... können Sie sie auch inline für eine einmalige Suchfunktion ausführen (siehe unten).

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

Hoffe das hilft.


Nur ein Delegat, das einen booleschen Wert zurückgibt. Es wird häufig in Filterlisten verwendet, kann aber überall verwendet werden.

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




predicate