Condividi tramite


Predicate<T> Delegato

Definizione

Rappresenta il metodo che definisce un set di criteri e determina se l'oggetto specificato soddisfa tali criteri.

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 

Parametri di tipo

T

Tipo di oggetto da confrontare.

Questo parametro di tipo è controvariante, ovvero puoi usare il tipo specificato o qualsiasi tipo meno derivato. Per altre informazioni sulla covarianza e la controvarianza, vedi Covarianza e controvarianza nei generics.

Parametri

obj
T

Oggetto da confrontare in base ai criteri definiti all'interno del metodo rappresentato da questo delegato.

Valore restituito

Boolean

true se obj soddisfa i criteri definiti all'interno del metodo rappresentato da questo delegato; in caso contrario false.

Esempio

Nell'esempio di codice seguente viene usato un Predicate<T> delegato con il Array.Find metodo per cercare una matrice di Point strutture. Nell'esempio viene definito in modo esplicito un delegato Predicate<T> denominato predicate e gli viene assegnato un metodo denominato FindPoints che restituisce true se il prodotto dei campi Point.X e Point.Y è maggiore di 100.000. Si noti che solitamente si utilizza un'espressione lambda anziché definire in modo esplicito un delegato di tipo Predicate<T>, come illustrato nel secondo esempio.

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

L'esempio seguente è identico a quello precedente, con la differenza che viene utilizzata un'espressione lambda per rappresentare il delegato Predicate<T>. Ogni elemento della matrice viene passato all'espressione lambda fino a quando l'espressione trova un elemento che soddisfa i criteri di points ricerca. In questo caso, l'espressione lambda restituisce true se il prodotto dei campi X e Y è maggiore di 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

Commenti

Questo delegato viene usato da diversi metodi delle Array classi e List<T> per cercare elementi nella raccolta.

In genere, il delegato è rappresentato da un'espressione Predicate<T> lambda. Poiché le variabili con ambito locale sono disponibili per l'espressione lambda, è facile testare per una condizione che non è nota esattamente in fase di compilazione. Questo è simulato nell'esempio seguente, che definisce una classe che contiene informazioni su una HockeyTeam squadra della National Hockey League e l'anno in cui è stata fondata. L'esempio definisce una matrice di valori integer che rappresentano anni e assegna in modo casuale un elemento della matrice a foundedBeforeYear, ovvero una variabile con ambito locale al metodo dell'esempio Main . Poiché le variabili con ambito locale sono disponibili per un'espressione lambda, l'espressione lambda passata al metodo è in grado di restituire un HockeyTeam oggetto per ogni team basato su o prima di List<T>.FindAll quell'anno.

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

Metodi di estensione

GetMethodInfo(Delegate)

Ottiene un oggetto che rappresenta il metodo rappresentato dal delegato specificato.

Si applica a

Vedi anche