Predicate<T> Delegar

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Representa o método que define um conjunto de critérios e determina se o objeto especificado atende a esses critérios.

C#

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

C#

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

Parâmetros de tipo

T

Especifica o tipo do objeto a ser comparado.

Este parâmetro de tipo é contravariante. Isso significa que é possível usar o tipo especificado ou qualquer tipo menos derivado. Para obter mais informações sobre covariância e contravariância, consulte Covariância e contravariância em genéricos.

Parâmetros

obj

T

O objeto a ser comparado com os critérios definidos dentro do método representado por esse delegado.

Valor Retornado

Boolean

true se obj atender aos critérios definidos dentro do método representado por esse delegado; caso contrário, false.

Exemplos

O exemplo de código a seguir usa um Predicate<T> delegado com o Array.Find método para pesquisar uma matriz de Point estruturas. O exemplo define explicitamente um Predicate<T> delegado nomeado predicate e atribui a ele um método chamado FindPoints que retorna true se o produto do e Point.Y dos Point.X campos for maior que 100.000. Observe que é comum usar uma expressão lambda em vez de definir explicitamente um delegado de tipo Predicate<T>, como ilustra o segundo exemplo.

C#

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

O exemplo a seguir é idêntico ao exemplo anterior, exceto que ele usa uma expressão lambda para representar o Predicate<T> delegado. Cada elemento da points matriz é passado para a expressão lambda até que a expressão encontre um elemento que atenda aos critérios de pesquisa. Nesse caso, a expressão lambda retornará true se o produto dos campos X e Y for maior que 100.000.

C#

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

Comentários

Esse delegado é usado por vários métodos e Array List<T> classes para pesquisar elementos na coleção.

Normalmente, o Predicate<T> delegado é representado por uma expressão lambda. Como as variáveis com escopo local estão disponíveis para a expressão lambda, é fácil testar uma condição que não é precisamente conhecida no momento da compilação. Isso é simulado no exemplo a seguir, que define uma HockeyTeam classe que contém informações sobre uma equipe da National Hockey League e o ano em que foi fundada. O exemplo define uma matriz de valores inteiros que representam anos e atribui aleatoriamente um elemento da matriz, foundedBeforeYearque é uma variável com escopo local para o método do Main exemplo. Como as variáveis com escopo local estão disponíveis para uma expressão lambda, a expressão lambda passada para o List<T>.FindAll método é capaz de retornar um HockeyTeam objeto para cada equipe fundada em ou antes desse ano.

C#

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

Métodos de Extensão

GetMethodInfo(Delegate)

Obtém um objeto que representa o método representado pelo delegado especificado.

Aplica-se a

Confira também

• Find<T>(T[], Predicate<T>)