(0) exportieren Drucken
Alle erweitern
Erweitern Minimieren
Dieser Artikel wurde maschinell übersetzt. Bewegen Sie den Mauszeiger über die Sätze im Artikel, um den Originaltext anzuzeigen. Weitere Informationen
Übersetzung
Original

Predicate<T>-Delegat

Stellt die Methode dar, die einen Satz von Kriterien definiert und bestimmt, ob das angegebene Objekt jene Kriterien erfüllt.

Namespace:  System
Assembly:  mscorlib (in mscorlib.dll)

public delegate bool Predicate<in T>(
	T obj
)

Typparameter

in T

Der Typ des zu vergleichenden Objekts.

Dieser Typparameter ist Contravariant. Das heißt, Sie können entweder den angegebenen Typ oder einen weniger abgeleiteten Typ verwenden. Weitere Informationen zu Ko- und Kontravarianz finden Sie unter Kovarianz und Kontravarianz in Generika.

Parameter

obj
Typ: T
Das Objekt, das mit den Kriterien verglichen werden soll, die innerhalb der durch diesen Delegaten dargestellten Methode definiert sind.

Rückgabewert

Typ: System.Boolean
true , wenn obj die innerhalb der durch diesen Delegaten dargestellten Methode definierten Kriterien erfüllt, andernfalls false.

Dieser Delegat wird von mehreren Methoden der Array-Klassen und der List<T>-Klassen verwendet, um nach Elementen in der Auflistung zu suchen.

Normalerweise wird der Predicate<T> Delegat durch einen Lambda-Ausdruck dargestellt. Da lokal bereichsbezogene Variablen des Lambda-Ausdrucks verfügbar sind, Testen ist einfach, für eine Bedingung, die nicht präzise zur Kompilierungszeit bekannt. Dies wird im folgenden Beispiel simuliert, das eine HockeyTeam-Klasse definiert, die Informationen über ein nationales Hockey-Liga-Team und Jahr enthält, in der es gestartet wurde. Im Beispiel wird ein Array ganzzahlige Werte, die eine über Jahre darstellen, und weist foundedBeforeYear zufällig ein Element des Arrays an, das eine Variable ist, die lokal der Main-Methode des Beispiels erstreckt. Da lokal bereichsbezogene Variablen an einen Lambda-Ausdruck verfügbar sind, ist der Lambda-Ausdruck, der die List<T>.FindAll-Methode übergeben wird, in der Lage, ein HockeyTeam-Objekt während der einzelnen Teams, das auf gestartet werden oder vorab dieses Jahr zurückzugeben.


using System;
using System.Collections.Generic;

public class HockeyTeam
{
   private string _name;
   private int _founded;

   public HockeyTeam(string name, int year)
   {
      _name = name;
      _founded = year;
   }

   public string Name {
      get { return _name; }
   }

   public int Founded {
      get { return _founded; }
   }
}

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      List<HockeyTeam> teams = new List<HockeyTeam>();
      teams.AddRange( new HockeyTeam[] { new HockeyTeam("Detroit Red Wings", 1926), 
                                         new HockeyTeam("Chicago Blackhawks", 1926),
                                         new HockeyTeam("San Jose Sharks", 1991),
                                         new HockeyTeam("Montreal Canadiens", 1909),
                                         new HockeyTeam("St. Louis Blues", 1967) } );
      int[] years = { 1920, 1930, 1980, 2000 };
      int foundedBeforeYear = years[rnd.Next(0, years.Length)];
      Console.WriteLine("Teams founded before {0}:", foundedBeforeYear);
      foreach (var team in teams.FindAll( x => x.Founded <= foundedBeforeYear))
         Console.WriteLine("{0}: {1}", team.Name, team.Founded);
   }
}
// The example displays output similar to the following:
//       Teams founded before 1930:
//       Detroit Red Wings: 1926
//       Chicago Blackhawks: 1926
//       Montreal Canadiens: 1909


Im folgenden Codebeispiel wird ein Predicate<T>-Delegat mit der Array.Find<T>-Methode verwendet, um ein Array der Point-Strukturen zu suchen. Das Beispiel explizit definiert einen Delegaten Predicate<T>, der mit dem Namen predicate und weist diesem eine Methode, die FindPoints, die true zurückgibt, wenn das Produkt der Point.X und Point.Y Felder größer als 100.000 ist. Beachten Sie, dass es üblich ist, einen Lambda-Ausdruck verwenden, anstatt einen Delegaten des Typs Predicate<T> explizit zu definieren, da das zweite Beispiel veranschaulicht.


using System;
using System.Drawing;

public class Example
{
   public static void Main()
   {
      // Create an array of Point structures.
      Point[] points = { new Point(100, 200), 
                         new Point(150, 250), new Point(250, 375), 
                         new Point(275, 395), new Point(295, 450) };

      // Define the Predicate<T> delegate.
      Predicate<Point> predicate = FindPoints;

      // Find the first Point structure for which X times Y  
      // is greater than 100000. 
      Point first = Array.Find(points, predicate);

      // Display the first structure found.
      Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y);
   }

   private static bool FindPoints(Point obj)
   {
      return obj.X * obj.Y > 100000;
   }
}
// The example displays the following output:
//        Found: X = 275, Y = 395


Das folgende Beispiel entspricht dem vorherigen Beispiel identisch, es verwendet einen Lambda-Ausdruck, um den Delegaten Predicate<T> darzustellen. Jedes Element des Arrays points wird z Lambda-Ausdruck übergeben, bis der Ausdruck ein Element, das mit den Suchkriterien entspricht. In diesem Fall gibt der Lambda-Ausdruck true zurück, wenn das Produkt der x- und Y-Felder größer als 100.000 ist.


using System;
using System.Drawing;

public class Example
{
   public static void Main()
   {
      // Create an array of Point structures.
      Point[] points = { new Point(100, 200), 
                         new Point(150, 250), new Point(250, 375), 
                         new Point(275, 395), new Point(295, 450) };

      // Find the first Point structure for which X times Y  
      // is greater than 100000. 
      Point first = Array.Find(points, x => x.X * x.Y > 100000 );

      // Display the first structure found.
      Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y);
   }
}
// The example displays the following output:
//        Found: X = 275, Y = 395


.NET Framework

Unterstützt in: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Unterstützt in: 4, 3.5 SP1

Portable Klassenbibliothek

Unterstützt in: Portable Klassenbibliothek

.NET für Windows Store-Apps

Unterstützt in: Windows 8

.NET für Windows Phone-Apps

Unterstützt in: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core-Rolle wird nicht unterstützt), Windows Server 2008 R2 (Server Core-Rolle wird mit SP1 oder höher unterstützt; Itanium wird nicht unterstützt)

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft