Predicate<T> Delegat
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Stellt die Methode dar, die einen Satz von Kriterien definiert und ermittelt, ob das angegebene Objekt diese Kriterien erfüllt.
generic <typename T>
public delegate bool Predicate(T obj);public delegate bool Predicate<in T>(T obj);public delegate bool Predicate<T>(T obj);type Predicate<'T> = delegate of 'T -> boolPublic Delegate Function Predicate(Of In T)(obj As T) As Boolean Public Delegate Function Predicate(Of T)(obj As T) As Boolean Typparameter
- T
Der Typ des zu vergleichenden Objekts.
Dieser Typparameter ist kontravariant. Das bedeutet, dass Sie entweder den angegebenen Typ oder einen weniger abgeleiteten Typ verwenden können. Weitere Informationen zu Kovarianz und Kontravarianz finden Sie unter Kovarianz und Kontravarianz in Generics.Parameter
- obj
- T
Das Objekt, das mit den Kriterien verglichen werden soll, die innerhalb der durch diesen Delegaten dargestellten Methode definiert sind.
Rückgabewert
true, wenn obj die innerhalb der durch diesen Delegaten dargestellten Methode definierten Kriterien erfüllt, andernfalls false.
Beispiele
Im folgenden Codebeispiel wird eine Predicate<T> Stellvertretung mit der Array.Find Methode verwendet, um ein Array von Point Strukturen zu durchsuchen. Das Beispiel definiert explizit einen Predicate<T> Delegaten namens und weist sie einer Methode FindPoints zupredicate, die zurückgegeben true wird, wenn das Produkt der Point.Y Point.X Felder größer als 100.000 ist. Beachten Sie, dass es üblich ist, einen Lambdaausdruck anstelle einer expliziten Definition eines Stellvertretungstyps Predicate<T>zu verwenden, wie 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
open System
open System.Drawing
let findPoints (obj: Point) =
obj.X * obj.Y > 100000
// Create an array of Point structures.
let points =
[| Point(100, 200)
Point(150, 250)
Point(250, 375)
Point(275, 395)
Point(295, 450) |]
// Define the Predicate<T> delegate.
let predicate = Predicate<Point> findPoints
// Find the first Point structure for which X times Y
// is greater than 100000.
let first = Array.Find(points, predicate)
// Display the first structure found.
printfn $"Found: X = {first.X}, Y = {first.Y}"
// The example displays the following output:
// Found: X = 275, Y = 395
Imports System.Drawing
Public Class Example
Public Shared Sub Main()
' Create an array of Point structures.
Dim points() As Point = { new Point(100, 200), new Point(150, 250),
new Point(250, 375), new Point(275, 395),
new Point(295, 450) }
' Define the Predicate(Of T) delegate.
Dim predicate As Predicate(Of Point) = AddressOf Example.FindPoints
' Find the first Point structure for which X times Y
' is greater than 100000.
Dim first As Point = Array.Find(points, predicate)
' Display the first structure found.
Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y)
End Sub
Private Shared Function FindPoints(obj As Point) As Boolean
Return obj.X * obj.Y > 100000
End Function
End Class
' The example displays the following output:
' Found: X = 275, Y = 395
Das folgende Beispiel ist identisch mit dem vorherigen Beispiel, es sei denn, es verwendet einen Lambda-Ausdruck, um die Predicate<T> Stellvertretung darzustellen. Jedes Element des points Arrays wird an den Lambda-Ausdruck übergeben, bis der Ausdruck ein Element findet, das den Suchkriterien entspricht. In diesem Fall gibt der Lambdaausdruck zurück true , wenn das Produkt der Felder X und Y 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
open System
open System.Drawing
// Create an array of Point structures.
let points =
[| Point(100, 200)
Point(150, 250)
Point(250, 375)
Point(275, 395)
Point(295, 450) |]
// Find the first Point structure for which X times Y
// is greater than 100000.
let first = Array.Find(points, fun x -> x.X * x.Y > 100000)
// Display the first structure found.
printfn $"Found: X = {first.X}, Y = {first.Y}"
// The example displays the following output:
// Found: X = 275, Y = 395
Imports System.Drawing
Public Class Example
Public Shared Sub Main()
' Create an array of Point structures.
Dim points() As Point = { 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.
Dim first As Point = Array.Find(points,
Function(x) x.X * x.Y > 100000 )
' Display the first structure found.
Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y)
End Sub
End Class
' The example displays the following output:
' Found: X = 275, Y = 395
Hinweise
Diese Stellvertretung wird von mehreren Methoden und Array List<T> Klassen verwendet, um nach Elementen in der Auflistung zu suchen.
In der Regel wird die Predicate<T> Stellvertretung durch einen Lambdaausdruck dargestellt. Da lokal bereichsbezogene Variablen für den Lambdaausdruck verfügbar sind, ist es einfach, auf eine Bedingung zu testen, die zur Kompilierungszeit nicht genau bekannt ist. Dies wird im folgenden Beispiel simuliert, das eine HockeyTeam Klasse definiert, die Informationen zu einem National Hockey League-Team und dem Jahr enthält, in dem sie gegründet wurde. Das Beispiel definiert ein Array mit ganzzahligen Werten, die Jahre darstellen, und weist zufällig ein Element des Arrays zu foundedBeforeYear, der eine Variable ist, die lokal auf die Methode des Beispiels Main festgelegt ist. Da lokale Variablen für einen Lambdaausdruck verfügbar sind, kann der lambda-Ausdruck, der an die List<T>.FindAll Methode übergeben wird, ein HockeyTeam Objekt für jedes Team zurückgeben, das auf oder vor diesem Jahr basiert.
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
open System
type HockeyTeam =
{ Name: string
Founded: int }
let rnd = Random()
let teams = ResizeArray()
teams.AddRange
[| { Name = "Detroit Red Wings"; Founded = 1926 }
{ Name = "Chicago Blackhawks"; Founded = 1926 }
{ Name = "San Jose Sharks"; Founded = 1991 }
{ Name = "Montreal Canadiens"; Founded = 1909 }
{ Name = "St. Louis Blues"; Founded = 1967 }|]
let years = [| 1920; 1930; 1980; 2000 |]
let foundedBeforeYear = years[rnd.Next(0, years.Length)]
printfn $"Teams founded before {foundedBeforeYear}:"
for team in teams.FindAll(fun x -> x.Founded <= foundedBeforeYear) do
printfn $"{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
Imports System.Collections.Generic
Public Class HockeyTeam
Private _name As String
Private _founded As Integer
Public Sub New(name As String, year As Integer)
_name = name
_founded = year
End Sub
Public ReadOnly Property Name As String
Get
Return _name
End Get
End Property
Public ReadOnly Property Founded As Integer
Get
Return _founded
End Get
End Property
End Class
Module Example
Public Sub Main()
Dim rnd As New Random()
Dim teams As New List(Of HockeyTeam)()
teams.AddRange( { 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) } )
Dim years() As Integer = { 1920, 1930, 1980, 2000 }
Dim foundedBeforeYear As Integer = years(rnd.Next(0, years.Length))
Console.WriteLine("Teams founded before {0}:", foundedBeforeYear)
For Each team in teams.FindAll( Function(x) x.Founded <= foundedBeforeYear )
Console.WriteLine("{0}: {1}", team.Name, team.Founded)
Next
End Sub
End Module
' The example displays output similar to the following:
' Teams founded before 1930:
' Detroit Red Wings: 1926
' Chicago Blackhawks: 1926
' Montreal Canadiens: 1909
Erweiterungsmethoden
| GetMethodInfo(Delegate) |
Ruft ein Objekt ab, das die Methode darstellt, die vom angegebenen Delegaten dargestellt wird. |