Exportar (0) Imprimir
Expandir todo
Expandir Minimizar
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Predicate<T> (Delegado)

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

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

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

Parámetros de tipo

in T

Tipo del objeto que se va a comparar.

Este parámetro de tipo es contravariante. Es decir, puede usar el tipo especificado o cualquier tipo menos derivado. Para obtener más información sobre la covarianza y la contravarianza, vea Covarianza y contravarianza en genéricos.

Parámetros

obj
Tipo: T
Objeto que se va a comparar según los criterios definidos en el método representado por este delegado.

Valor devuelto

Tipo: System.Boolean
Es true si obj cumple los criterios definidos en el método representado por este delegado; de lo contrario, es false.

Varios métodos de las clases Array y List<T> utilizan este delegado para buscar elementos en la colección.

Normalmente, una expresión lambda representa el delegado de Predicate<T> . Dado que las variables localmente ámbito están disponibles para la expresión lambda, es fácil probar una condición que no se distinguen exacto en tiempo de compilación. Esto se simula en el ejemplo siguiente, que define una clase de HockeyTeam que contiene información sobre un equipo de la liga de hockey de National y el año en los que se fundada. El ejemplo define una matriz de valores enteros que representan años, y asigna de forma aleatoria un elemento de matriz a foundedBeforeYear, que es una variable que localmente en el ámbito del método de Main de ejemplo. Dado que las variables localmente ámbito están disponibles para una expresión lambda, la expresión lambda pasada al método de List<T>.FindAll puede devolver un objeto de HockeyTeam por cada equipo fundado en o para 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


En el ejemplo de código siguiente se utiliza un delegado Predicate<T> con el método Array.Find<T> para buscar en una matriz de estructuras Point. El ejemplo explícitamente define un delegado de Predicate<T> denominado predicate y le asigna un método denominado FindPoints que devuelve true si el producto de los campos de Point.X y de Point.Y es mayor que 100.000. Observe que es habitual utilizar una expresión lambda en lugar de definir explícitamente un delegado de Predicate<T>tipo, 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


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


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft