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

Definition

Sucht nach einem Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, und gibt das erste Vorkommen im gesamten Array zurück.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

Typparameter

T

Der Typ der Elemente des Arrays.The type of the elements of the array.

Parameter

array
T[]

Das zu durchsuchende eindimensionale und nullbasierte Array.The one-dimensional, zero-based array to search.

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

Das Prädikat, das die Bedingungen für das Element definiert, nach dem gesucht werden soll.The predicate that defines the conditions of the element to search for.

Gibt zurück

T T T T

Das erste Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, sofern vorhanden, andernfalls der Standardwert für den Typ T.The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type T.

Ausnahmen

array ist null.array is null.

- oder --or- match ist null.match is null.

Beispiele

Im folgenden Beispiel wird ein Predicate<T>-Delegat mit der generischen Methode Find verwendet, um ein Array von Point-Strukturen zu durchsuchen.The following example uses a Predicate<T> delegate with the Find generic method to search an array of Point structures. Die Methode, die der Delegat darstellt (ProductGT10), gibt true zurück, wenn das Produkt der X-und Y-Felder größer als 100.000 ist.The method the delegate represents, ProductGT10, returns true if the product of the X and Y fields is greater than 100,000. Die Find-Methode ruft den-Delegaten für jedes Element des Arrays auf und gibt den ersten Punkt zurück, der die Test Bedingung erfüllt.The Find method calls the delegate for each element of the array, returning the first point that meets the test condition.

Hinweis

Visual Basic und C# Benutzer müssen den Delegaten nicht explizit erstellen oder das Typargument der generischen Methode angeben.Visual Basic and C# users do not have to create the delegate explicitly or specify the type argument of the generic method. Die Compiler bestimmen die erforderlichen Typen aus den Methoden Argumenten, die Sie angeben.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

Anstatt eine Methode explizit mit der erforderlichen Signatur zu definieren, einen Predicate<T>-Delegaten zu instanziieren und den Delegaten an die Find-Methode zu übergeben, ist es üblich, einen Lambda-Ausdruck zu verwenden.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. Das folgende Beispiel ist mit dem vorherigen identisch, mit der Ausnahme, dass ein Lambda-Ausdruck als match-Argument verwendet wird.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

Hinweise

Der Predicate<T> ist ein Delegat für eine Methode oder ein Lambda-Ausdruck, der true zurückgibt, wenn das an ihn übergebenen Objekt mit den Bedingungen übereinstimmt, die im Delegaten oder Lambda-Ausdruck definiert sind.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. Die Elemente von array werden einzeln an Predicate<T>, beginnend mit dem ersten Element und mit dem letzten Element.The elements of array are individually passed to the Predicate<T>, starting with the first element and ending with the last element. Die Verarbeitung wird beendet, wenn eine Entsprechung gefunden wird.Processing is stopped when a match is found.

Bei dieser Methode handelt es sich um einen O (n)-Vorgang, bei dem n der Length von array ist.This method is an O(n) operation, where n is the Length of array.

Gilt für:

Siehe auch