Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Delegado Predicate<T>

 

Publicado: octubre de 2016

Representa el método que define un conjunto de criterios y determina si el objeto especificado cumple con dichos criterios.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

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

Parámetros

obj
Type: T

El objeto que se compara con los criterios definidos dentro del método representado por este delegado.

Valor devuelto

Type: System.Boolean

trueSi obj cumple los criterios definidos en el método representado por este delegado; en caso contrario, false.

Parámetros de tipo

inT

El tipo de objeto que se va a comparar.

Este delegado es utilizado por varios métodos de la Array y List<T> clases para buscar elementos de la colección.

Normalmente, el Predicate<T> delegado se representa mediante una expresión lambda. Dado que las variables de ámbito local están disponibles para la expresión lambda, es fácil probar una condición que no se conoce de forma precisa en tiempo de compilación. Esto se simula en el ejemplo siguiente, que define un HockeyTeam clase que contiene información sobre un equipo liga nacional de Hockey y el año en el que se basa. En el ejemplo se define una matriz de valores enteros que representan años y asigna de forma aleatoria un elemento de la matriz en foundedBeforeYear, que es una variable que tiene ámbito local para el ejemplo Main método. Como variables de ámbito local están disponibles para una expresión lambda, expresión lambda pasada a la List<T>.FindAll método es capaz de devolver un HockeyTeam objeto para cada equipo que se basó en o antes de ese año.

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

El siguiente ejemplo de código utiliza un Predicate<T> delegado con el Array.Find<T> método para buscar en una matriz de Point estructuras. En el ejemplo se define explícitamente un Predicate<T> delegado denominado predicate y le asigna un método denominado FindPoints que devuelve true si el producto de la Point.X y Point.Y campos es mayor que 100.000. Tenga en cuenta que es habitual usar una expresión lambda, en lugar de definir explícitamente un delegado del tipo Predicate<T>, como se muestra en el segundo ejemplo.

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

En el siguiente ejemplo es idéntico al ejemplo anterior, salvo que usa una expresión lambda para representar el Predicate<T> delegar. Cada elemento de la points matriz se pasa a la expresión lambda hasta que la expresión busca un elemento que cumpla los criterios de búsqueda. En este caso, la expresión lambda devuelve true si el producto de los campos X e Y es mayor que 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

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 2.0
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: