Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Delegato Predicate<T>

 

Data di pubblicazione: ottobre 2016

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

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

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

Parametri

obj
Type: T

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

Valore restituito

Type: System.Boolean

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

Parametri tipo

inT

Il tipo dell'oggetto da confrontare.

Questo delegato è utilizzato da numerosi metodi per il Array e List<T> classi per la ricerca di elementi nella raccolta.

In genere, il Predicate<T> delegato è rappresentato da un'espressione lambda. Poiché le variabili con ambite locale sono disponibili per l'espressione lambda, è facile da testare per una condizione che non è noto con precisione in fase di compilazione. Questa situazione viene simulata nell'esempio seguente, che definisce un HockeyTeam classe che contiene informazioni su un team lega Hockey nazionali e l'anno in cui è stata fondata. L'esempio definisce una matrice di valori interi che rappresentano anni e assegna in modo casuale un elemento della matrice da foundedBeforeYear, che è una variabile locale con ambito limitato all'esempio Main metodo. Dato che le variabili con ambite locale sono disponibili in un'espressione lambda, l'espressione lambda passata al List<T>.FindAll metodo è in grado di restituire un HockeyTeam oggetto per ogni team fondata o prima dell'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

Nell'esempio di codice viene illustrato come utilizzare un Predicate<T> delegato con il Array.Find<T> metodo per la ricerca di 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

L'esempio seguente è identico a quello precedente, con la differenza che viene utilizzata un'espressione lambda per rappresentare il delegato Predicate<T>. Ogni elemento del points matrice viene passata all'espressione lambda fino a quando l'espressione Trova un elemento che soddisfa i criteri di 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

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 2.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: