Predicate<T> 대리자

정의

조건 집합을 정의하고 지정된 개체가 이러한 조건을 충족하는지 여부를 결정하는 메서드를 나타냅니다.Represents the method that defines a set of criteria and determines whether the specified object meets those criteria.

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 -> bool
Public Delegate Function Predicate(Of In T)(obj As T) As Boolean 
Public Delegate Function Predicate(Of T)(obj As T) As Boolean 

형식 매개 변수

T

비교할 개체의 형식입니다.The type of the object to compare.

이 형식 매개 변수는 반공변(Contravariant)입니다. 즉, 지정한 형식이나 더 적게 파생된 모든 형식을 사용할 수 있습니다. 공변성(Covariance) 및 반공변성(Contravariance)에 대한 자세한 내용은 제네릭의 공변성(Covariance) 및 반공변성(Contravariance)을 참조하세요.

매개 변수

obj
T

이 대리자가 나타내는 메서드에 정의된 조건과 비교할 개체입니다.The object to compare against the criteria defined within the method represented by this delegate.

반환 값

Boolean

true가 이 대리자가 나타내는 메서드에 정의된 조건을 충족하면 obj이고, 그렇지 않으면 false입니다.true if obj meets the criteria defined within the method represented by this delegate; otherwise, false.

상속
Predicate<T>

예제

다음 코드 예제에서는 Array.Find 메서드와 함께 Predicate<T> 대리자를 사용 하 여 Point 구조체의 배열을 검색 합니다.The following code example uses a Predicate<T> delegate with the Array.Find method to search an array of Point structures. 이 예제에서는 predicate 이라는 Predicate<T> 대리자를 명시적으로 정의 하 고 Point.XPoint.Y 필드의 제품이 10만 보다 큰 경우 true를 반환 하는 FindPoints 라는 메서드를 할당 합니다.The example explicitly defines a Predicate<T> delegate named predicate and assigns it a method named FindPoints that returns true if the product of the Point.X and Point.Y fields is greater than 100,000. 두 번째 예제에서 보여 주는 것 처럼 Predicate<T>형식의 대리자를 명시적으로 정의 하는 대신 람다 식을 사용 합니다.Note that it is customary to use a lambda expression rather than to explicitly define a delegate of type Predicate<T>, as the second example illustrates.

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

다음 예제는 람다 식을 사용 하 여 Predicate<T> 대리자를 표시 한다는 점을 제외 하 고 이전 예제와 동일 합니다.The following example is identical to the previous example, except that it uses a lambda expression to represent the Predicate<T> delegate. 식이 검색 조건을 충족 하는 요소를 찾을 때까지 points 배열의 각 요소가 람다 식에 전달 됩니다.Each element of the points array is passed to the lambda expression until the expression finds an element that meets the search criteria. 이 경우 X 및 Y 필드의 곱이 10만 보다 큰 경우에는 람다 식이 true을 반환 합니다.In this case, the lambda expression returns true if the product of the X and Y fields is greater than 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
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

설명

이 대리자는 Array의 여러 메서드 및 List<T> 클래스에서 컬렉션의 요소를 검색 하는 데 사용 됩니다.This delegate is used by several methods of the Array and List<T> classes to search for elements in the collection.

일반적으로 Predicate<T> 대리자는 람다 식으로 표현 됩니다.Typically, the Predicate<T> delegate is represented by a lambda expression. 로컬 범위 변수를 람다 식에 사용할 수 있으므로 정확 하 게 컴파일 타임에 알려지지 않은 조건에 대 한 테스트 하기 쉽습니다.Because locally scoped variables are available to the lambda expression, it is easy to test for a condition that is not precisely known at compile time. 이는 국가별 Hockey 리그 팀 및 설립 연도에 대 한 정보를 포함 하는 HockeyTeam 클래스를 정의 하는 다음 예제에서 시뮬레이션 되었습니다.This is simulated in the following example, which defines a HockeyTeam class that contains information about a National Hockey League team and the year in which it was founded. 이 예제에서는 연도를 나타내는 정수 값의 배열을 정의 하 고, 배열의 한 요소를 foundedBeforeYear에 임의로 할당 합니다 .이 변수는 로컬에서 예제의 Main 메서드로 범위가 지정 된 변수입니다.The example defines an array of integer values that represent years, and randomly assigns one element of the array to foundedBeforeYear, which is a variable that is locally scoped to the example's Main method. 람다 식에는 로컬로 범위가 지정 된 변수를 사용할 수 있기 때문에 List<T>.FindAll 메서드에 전달 된 람다 식이 해당 연도 또는 그 이전에 설립 된 각 팀에 대 한 HockeyTeam 개체를 반환할 수 있습니다.Because locally scoped variables are available to a lambda expression, the lambda expression passed to the List<T>.FindAll method is able to return a HockeyTeam object for each team founded on or before that year.

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

지정된 대리자가 나타내는 메서드를 나타내는 개체를 가져옵니다.Gets an object that represents the method represented by the specified delegate.

적용 대상

추가 정보