Array.Find<T>(T[], Predicate<T>) Método

Definición

Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve la primera aparición en toda la matriz Array.Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire Array.

public:
generic <typename T>
 static T Find(cli::array <T> ^ array, Predicate<T> ^ match);
public static T Find<T> (T[] array, Predicate<T> match);
static member Find : 'T[] * Predicate<'T> -> 'T
Public Shared Function Find(Of T) (array As T(), match As Predicate(Of T)) As T

Parámetros de tipo

T

Tipo de los elementos de la matriz.The type of the elements of the array.

Parámetros

array
T[]

Matriz unidimensional de base cero en la que se va a buscar.The one-dimensional, zero-based array to search.

match
Predicate<T>

El predicado que define las condiciones del elemento que se va a buscar.The predicate that defines the conditions of the element to search for.

Devoluciones

T

Primer elemento que coincide con las condiciones definidas por el predicado especificado, si se encuentra; de lo contrario, valor predeterminado para el tipo T.The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type T.

Excepciones

array es null.array is null.

o bien-or- match es null.match is null.

Ejemplos

En el ejemplo siguiente se usa un delegado Predicate<T> con el método genérico Find para buscar en una matriz de estructuras Point.The following example uses a Predicate<T> delegate with the Find generic method to search an array of Point structures. El método que representa el delegado, ProductGT10, devuelve true si el producto de los campos X e y es mayor que 100.000.The method the delegate represents, ProductGT10, returns true if the product of the X and Y fields is greater than 100,000. El método Find llama al delegado para cada elemento de la matriz y devuelve el primer punto que cumple la condición de prueba.The Find method calls the delegate for each element of the array, returning the first point that meets the test condition.

Nota

Visual Basic y C# los usuarios no tienen que crear el delegado explícitamente ni especificar el argumento de tipo del método genérico.Visual Basic and C# users do not have to create the delegate explicitly or specify the type argument of the generic method. Los compiladores determinan los tipos necesarios a partir de los argumentos de método que suministre.The compilers determine the necessary types from the method arguments you supply.

using System;
using System.Drawing;

public class Example
{
    public static void Main()
    {
        // Create an array of five 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, ProductGT10);

        // Display the first structure found.
        Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y);
    }

    // Return true if X times Y is greater than 100000.
    private static bool ProductGT10(Point p)
    {
        return p.X * p.Y > 100000;
    }
}
// The example displays the following output:
//       Found: X = 275, Y = 395
Imports System.Drawing

Public Module Example
   Public Sub Main()
      ' Create an array of five 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, AddressOf ProductGT10)

      ' Display the first structure found.
      Console.WriteLine("Found: X = {0}, Y = {1}", _
            first.X, first.Y)
   End Sub

   ' Return true if X times Y is greater than 100000.
   Private Function ProductGT10(ByVal p As Point) As Boolean
      Return p.X * p.Y > 100000 
   End Function
End Module
' The example displays the following output:
'       Found: X = 275, Y = 395

En lugar de definir explícitamente un método con la firma necesaria, crear una instancia de un delegado Predicate<T> y pasar el delegado al método Find, es necesario usar una expresión lambda.Rather than explicitly defining a method with the necessary signature, instantiating a Predicate<T> delegate, and passing the delegate to the Find method, it is customary to use a lambda expression. El ejemplo siguiente es idéntico al anterior, salvo que usa una expresión lambda como argumento match.The following example is identical to the previous one, except that it uses a lambda expression as the match argument.

using System;
using System.Drawing;

public class Example
{
    public static void Main()
    {
        // Create an array of five 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, p => p.X * p.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
Imports System.Drawing

Public Module Example
   Public Sub Main()
      ' Create an array of five 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(p) p.X * p.Y > 100000)

      ' Display the first structure found.
      Console.WriteLine("Found: X = {0}, Y = {1}", _
            first.X, first.Y)
   End Sub
End Module
' The example displays the following output:
'       Found: X = 275, Y = 395

Comentarios

El Predicate<T> es un delegado para un método o una expresión lambda que devuelve true si el objeto que se pasa coincide con las condiciones definidas en el delegado o expresión lambda.The Predicate<T> is a delegate to a method or a lambda expression that returns true if the object passed to it matches the conditions defined in the delegate or lambda expression. Los elementos de array se pasan individualmente a la Predicate<T>, comenzando por el primer elemento y terminando por el último elemento.The elements of array are individually passed to the Predicate<T>, starting with the first element and ending with the last element. El procesamiento se detiene cuando se encuentra una coincidencia.Processing is stopped when a match is found.

Este método es una operación O (n), donde n es el Length de array.This method is an O(n) operation, where n is the Length of array.

Se aplica a

Consulte también: