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

Definizione

Cerca un elemento che soddisfi le condizioni definite nel predicato specificato e restituisce la prima occorrenza all'interno dell'intero oggetto 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

Parametri di tipo

T

Tipo degli elementi della matrice.The type of the elements of the array.

Parametri

array
T[]

Matrice unidimensionale in base zero in cui eseguire la ricerca.The one-dimensional, zero-based array to search.

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

Predicato che definisce le condizioni dell'elemento da cercare.The predicate that defines the conditions of the element to search for.

Restituisce

T T T T

Primo elemento che soddisfa le condizioni definite dal predicato specificato, se trovato; in caso contrario, viene restituito il valore predefinito del tipo T.The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type T.

Eccezioni

array è null.array is null.

In alternativa-or- match è null.match is null.

Esempi

L'esempio seguente usa un' Predicate<T> delegato con il Find metodo generico per la ricerca di una matrice di Point strutture.The following example uses a Predicate<T> delegate with the Find generic method to search an array of Point structures. Il metodo rappresentato dal delegato, ProductGT10, restituisce true se il prodotto dei campi di X e Y è maggiore di 100.000.The method the delegate represents, ProductGT10, returns true if the product of the X and Y fields is greater than 100,000. Il Find metodo chiama il delegato per ogni elemento della matrice, restituendo il primo punto che soddisfa la condizione di test.The Find method calls the delegate for each element of the array, returning the first point that meets the test condition.

Nota

Gli utenti di c# e Visual Basic non sono necessario creare in modo esplicito il delegato o specificare l'argomento di tipo del metodo generico.Visual Basic and C# users do not have to create the delegate explicitly or specify the type argument of the generic method. I compilatori di determinano i tipi necessari da argomenti del metodo che è fornire.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

Invece di definire in modo esplicito un metodo con la firma necessario, creare un'istanza di un Predicate<T> delegare e passa il delegato per il Find metodo, è facoltativa per usare un'espressione 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. Nell'esempio seguente è identico a quello precedente, ad eccezione del fatto che usa un'espressione lambda come il match argomento.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

Commenti

Il Predicate<T> è un delegato a un metodo o un'espressione lambda che restituisce true se l'oggetto passato a corrisponda alle condizioni definite nel delegato o un'espressione 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. Gli elementi della array vengono passati singolarmente al Predicate<T>, inizia il primo elemento e termina con l'ultimo elemento.The elements of array are individually passed to the Predicate<T>, starting with the first element and ending with the last element. L'elaborazione viene arrestata quando viene trovata una corrispondenza.Processing is stopped when a match is found.

Questo metodo è un'operazione O (n) operazione, in cui n è la Length di array.This method is an O(n) operation, where n is the Length of array.

Si applica a

Vedi anche