Array.Find(T[], Predicate<T>) Array.Find(T[], Predicate<T>) Array.Find(T[], Predicate<T>) Array.Find(T[], Predicate<T>) Method

Definição

Pesquisa um elemento que corresponde às condições definidas pelo predicado especificado e retorna a primeira ocorrência em toda a 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

O tipo dos elementos da matriz.The type of the elements of the array.

Parâmetros

array
T[]

A matriz unidimensional, baseada em zero, a ser pesquisada.The one-dimensional, zero-based array to search.

match
Predicate<T> Predicate<T> Predicate<T> Predicate<T>

O predicado que define as condições do elemento a ser pesquisado.The predicate that defines the conditions of the element to search for.

Retornos

T T T T

O primeiro elemento que corresponde às condições definidas pelo predicado especificado, se encontrado; caso contrário, o valor padrão para o tipo T.The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type T.

Exceções

array é null.array is null.

- ou --or- match é null.match is null.

Exemplos

O exemplo a seguir usa uma Predicate<T> delegado com o Find método genérico para pesquisar uma matriz de Point estruturas.The following example uses a Predicate<T> delegate with the Find generic method to search an array of Point structures. O método que o delegado representa, ProductGT10, retorna true se o produto dos campos X e Y for maior 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. O Find método chama o delegado para cada elemento da matriz, retornando o primeiro ponto que atenda à condição de teste.The Find method calls the delegate for each element of the array, returning the first point that meets the test condition.

Observação

Visual Basic e c# que os usuários não é necessário que criar o delegado explicitamente ou especificar o argumento de tipo do 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. Os compiladores de determinam os tipos necessários dos argumentos de método que você fornecer.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

Em vez de definir explicitamente um método com a assinatura necessária, criando uma instância de um Predicate<T> delegar e passando o delegado para o Find método, é comum usar uma expressão 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. O exemplo a seguir é idêntico ao anterior, exceto que ele usa uma expressão lambda como o match argumento.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

Comentários

O Predicate<T> é um delegado para um método ou uma expressão lambda que retorna true se o objeto passado para ele corresponda às condições definidas na expressão de delegado ou 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. Os elementos de array são passados individualmente para o Predicate<T>, começando com o primeiro elemento e terminando com o último elemento.The elements of array are individually passed to the Predicate<T>, starting with the first element and ending with the last element. O processamento é interrompido quando uma correspondência for encontrada.Processing is stopped when a match is found.

Este método é uma operação O(n), em que n é o Length de array.This method is an O(n) operation, where n is the Length of array.

Aplica-se a

Veja também