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

Référence

Définition

Espace de noms:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Source:: Array.cs

Source:: Array.cs

Source:: Array.cs

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

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

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.

Paramètres

array: T[]

Tableau unidimensionnel basé sur zéro à rechercher.

match: Predicate<T>

Prédicat qui définit les conditions de l’élément à rechercher.

Retours

Premier élément qui correspond aux conditions définies par le prédicat spécifié, s’il est trouvé ; sinon, la valeur par défaut du type T.

Exceptions

ArgumentNullException

array est null.

-ou-

match est 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. 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. 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.

Note

Les utilisateurs Visual Basic, C# et F# 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. Les compilateurs déterminent les types nécessaires à partir des arguments de méthode que vous fournissez.

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

open System
open System.Drawing

// Return true if X times Y is greater than 100000.
let productGT10 (p: Point) = p.X * p.Y > 100000

// Create an array of five Point structures.
let points = 
    [| Point(100, 200)
       Point(150, 250)
       Point(250, 375)
       Point(275, 395)
       Point(295, 450) |]

// Find the first Point structure for which X times Y
// is greater than 100000.
let first = Array.Find(points, productGT10)
// let first = Array.find productGT10 points

// Display the first structure found.
printfn $"Found: X = {first.X}, Y = {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, 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

Au lieu de définir explicitement une méthode avec la signature nécessaire, instancier un délégué Predicate<T> et passer le délégué à la méthode Find, il est habituel d’utiliser une expression lambda. L’exemple suivant est identique à celui précédent, sauf qu’il utilise une expression lambda comme argument match.

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

open System
open System.Drawing

let points = 
    [| Point(100, 200)
       Point(150, 250)
       Point(250, 375)
       Point(275, 395)
       Point(295, 450) |]
// Find the first Point structure for which X times Y
// is greater than 100000.
let first = Array.Find(points, fun p -> p.X * p.Y > 100000)
// let first = points |> Array.find (fun p -> p.X * p.Y > 100000) 

// Display the first structure found.
printfn $"Found: X = {first.X}, Y = {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

L'Predicate<T> est un délégué à une méthode ou à une expression lambda qui retourne true si l’objet passé à celui-ci correspond aux conditions définies dans le délégué ou l’expression lambda. Les éléments de array sont transmis individuellement au Predicate<T>, en commençant par le premier élément et en se terminant par le dernier élément. Le traitement est arrêté lorsqu’une correspondance est trouvée.

Cette méthode est une opération O(n), où n est la Length de array.

Dans F#, la fonction Array.find peut être utilisée à la place.

S’applique à

Partager via