Číst v angličtině

Sdílet prostřednictvím

Predicate<T> Delegát

  • Reference

Definice

Obor názvů:
System
Sestavení:
System.Runtime.dll
Sestavení:
mscorlib.dll
Sestavení:
netstandard.dll

Představuje metodu, která definuje sadu kritérií a určuje, zda zadaný objekt splňuje tato kritéria.

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

Parametry typu

T

Typ objektu, který chcete porovnat.

Tento parametr typu je kontravariantní. To znamená, že můžete použít buď zadaný typ, nebo libovolný typ, který je méně odvozený. Další informace o kovarianci a kontravarianci najdete v tématu popisujícím kovarianci a kontravarianci u parametrického polymorfismu.

Parametry

obj
T

Objekt, který se má porovnat s kritérii definovanými v rámci metody reprezentované tímto delegátem.

Návratová hodnota

Boolean

true pokud obj splňuje kritéria definovaná v rámci metody reprezentované tímto delegátem, falsejinak .

Příklady

Následující příklad kódu používá delegáta Predicate<T> s metodou Array.Find k vyhledávání pole Point struktur. Příklad explicitně definuje delegáta Predicate<T> s názvem predicate FindPoints a přiřadí ji metodu, která vrátí true , pokud je součin Point.X a Point.Y pole větší než 100 000. Všimněte si, že je vlastní použít výraz lambda místo explicitně definovat delegát typu Predicate<T>, jak ukazuje druhý příklad.

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

Následující příklad je stejný jako v předchozím příkladu, s tím rozdílem, že používá výraz lambda k reprezentaci delegáta Predicate<T> . Každý prvek points pole se předá výrazu lambda, dokud výraz nenajde prvek, který splňuje kritéria hledání. V tomto případě výraz lambda vrátí true , pokud je součin polí X a Y větší než 100 000.

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

Poznámky

Tento delegát je používán několika metodami Array a List<T> třídami k hledání prvků v kolekci.

Predicate<T> Delegát je obvykle reprezentován výrazem lambda. Vzhledem k tomu, že proměnné v místním oboru jsou pro výraz lambda k dispozici, je snadné testovat podmínku, která není přesně známa v době kompilace. Toto je simulované v následujícím příkladu, který definuje HockeyTeam třídu, která obsahuje informace o týmu National Hockey League a o roce, ve kterém byla založena. Příklad definuje pole celočíselných hodnot, které představují roky, a náhodně přiřadí jeden prvek pole foundedBeforeYear, což je proměnná, která je místně vymezena na metodu příkladu Main . Vzhledem k tomu, že proměnné s místním oborem jsou k dispozici pro výraz lambda, výraz lambda předaný List<T>.FindAll metodě může vrátit HockeyTeam objekt pro každý tým založený na daném roce nebo před tímto rokem.

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

Metody rozšíření

GetMethodInfo(Delegate)

Získá objekt, který představuje metodu reprezentovanou zadaným delegátem.

Platí pro

Viz také