Predicate<T> 委托
定义
重要
一些信息与预发行产品相关，相应产品在发行之前可能会进行重大修改。 对于此处提供的信息，Microsoft 不作任何明示或暗示的担保。
表示一种方法，该方法定义一组条件并确定指定对象是否符合这些条件。
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 类型参数
参数
- obj
- T
要按照由此委托表示的方法中定义的条件进行比较的对象。
返回值
如果 obj 符合由此委托表示的方法中定义的条件，则为 true；否则为 false。
示例
下面的代码示例使用 Predicate<T> 具有 Array.Find 方法的 Point 委托来搜索结构数组。 该示例显式定义一个Predicate<T>命名predicate的委托，并为其分配一个命名FindPoints的方法，该方法在字段Point.Y的Point.X乘积大于 100，000 时返回true。 请注意，通常使用 lambda 表达式而不是显式定义类型的 Predicate<T>委托，如第二个示例所示。
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
以下示例与上一个示例相同，只不过它使用 lambda 表达式来表示 Predicate<T> 委托。 数组的每个元素 points 将传递到 lambda 表达式，直到表达式找到满足搜索条件的元素。 在这种情况下，lambda 表达式返回 true X 和 Y 字段的乘积大于 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
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
注解
此委托由多个方法和类用于ArrayList<T>搜索集合中的元素。
通常， Predicate<T> 委托由 lambda 表达式表示。 由于本地范围的变量对 lambda 表达式可用，因此可以轻松测试编译时无法准确知道的条件。 以下示例中模拟了这一点，该类定义一个 HockeyTeam 类，其中包含有关国家曲棍球联赛球队的信息以及创建该团队的年份。 该示例定义表示年份的整数值的数组，并随机将数组的一个元素分配给该数组，该数组 foundedBeforeYear是一个变量，该变量在本地限定为示例 Main 的方法。 由于本地范围的变量可用于 lambda 表达式，因此传递给 List<T>.FindAll 该方法的 lambda 表达式能够返回 HockeyTeam 在该年份或之前创建的每个团队的对象。
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
扩展方法
| GetMethodInfo(Delegate) |
获取指示指定委托表示的方法的对象。 |