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

Définition

Recherche un élément qui correspond aux conditions définies par le prédicat spécifié et retourne la première occurrence dans le Array entier.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

Paramètres de type

T

Type des éléments du tableau.The type of the elements of the array.

Paramètres

array
T[]

Le tableau de base zéro unidimensionnel à explorer.The one-dimensional, zero-based array to search.

match
Predicate<T>

Le prédicat qui définit les conditions de l'élément à rechercher.The predicate that defines the conditions of the element to search for.

Retours

T

Premier élément qui correspond aux conditions définies par le prédicat spécifié, s’il est trouvé ; sinon, valeur par défaut du type T.The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type T.

Exceptions

array a la valeur null.array is null.

-ou--or- match a la valeur null.match is null.

Exemples

L’exemple suivant utilise un délégué Predicate<T> avec la méthode générique Find pour rechercher un tableau de structures Point.The following example uses a Predicate<T> delegate with the Find generic method to search an array of Point structures. La méthode que le délégué représente, ProductGT10, retourne true si le produit des champs X et Y est supérieur à 100 000.The method the delegate represents, ProductGT10, returns true if the product of the X and Y fields is greater than 100,000. La méthode Find appelle le délégué pour chaque élément du tableau, en retournant le premier point qui répond à la condition de test.The Find method calls the delegate for each element of the array, returning the first point that meets the test condition.

Notes

Visual Basic et C# les utilisateurs n’ont pas besoin de créer le délégué explicitement ou de spécifier l’argument de type de la méthode générique.Visual Basic and C# users do not have to create the delegate explicitly or specify the type argument of the generic method. Les compilateurs déterminent les types nécessaires à partir des arguments de méthode que vous fournissez.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

Plutôt que de définir explicitement une méthode avec la signature nécessaire, d’instancier un délégué Predicate<T> et de passer le délégué à la méthode Find, il est personnalisé d’utiliser une expression 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. L’exemple suivant est identique au précédent, à ceci près qu’il utilise une expression lambda comme argument 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

Remarques

Le Predicate<T> est un délégué à une méthode ou une expression lambda qui retourne true si l’objet qui lui est passé correspond aux conditions définies dans le délégué ou l’expression 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. Les éléments de array sont passés individuellement à la Predicate<T>, en commençant par le premier élément et en terminant par le dernier élément.The elements of array are individually passed to the Predicate<T>, starting with the first element and ending with the last element. Le traitement s’arrête lorsqu’une correspondance est trouvée.Processing is stopped when a match is found.

Cette méthode est une opération O (n), où n est le Length de array.This method is an O(n) operation, where n is the Length of array.

S’applique à

Voir aussi