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

Definicja

Wyszukuje element, który odpowiada warunkom zdefiniowanym przez określony predykat, i zwraca pierwsze wystąpienie w całym 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

Parametry typu

T

Typ elementów tablicy.The type of the elements of the array.

Parametry

array
T[]

Tablica Jednowymiarowa, która ma być wyszukiwana.The one-dimensional, zero-based array to search.

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

Predykat definiujący warunki elementu, który ma zostać wyszukany.The predicate that defines the conditions of the element to search for.

Zwraca

T T T T

Pierwszy element, który odpowiada warunkom zdefiniowanym przez określony predykat, jeśli znaleziono; w przeciwnym razie wartość domyślna dla typu T.The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type T.

Wyjątki

array jest null.array is null.

—lub—-or- match jest null.match is null.

Przykłady

Poniższy przykład używa delegata Predicate<T> z metodą generyczną Find, aby przeszukać tablicę struktur Point.The following example uses a Predicate<T> delegate with the Find generic method to search an array of Point structures. Metoda reprezentowana przez delegata, ProductGT10, zwraca true, jeśli iloczyn pól X i Y jest większy niż 100 000.The method the delegate represents, ProductGT10, returns true if the product of the X and Y fields is greater than 100,000. Metoda Find Wywołuje delegata dla każdego elementu tablicy, zwracając pierwszy punkt, który spełnia warunek testu.The Find method calls the delegate for each element of the array, returning the first point that meets the test condition.

Uwaga

Visual Basic i C# użytkownicy nie muszą jawnie tworzyć delegatów ani określać argumentu Type metody generycznej.Visual Basic and C# users do not have to create the delegate explicitly or specify the type argument of the generic method. Kompilatory określają wymagane typy z argumentów metody, które dostarczasz.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

Zamiast jawnie zdefiniować metodę z niezbędnym podpisem, tworzenie wystąpienia delegata Predicate<T> i przekazywanie delegata do metody Find, jest to niestandardowe użycie wyrażenia 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. Poniższy przykład jest identyczny z poprzednim, z tą różnicą, że używa wyrażenia lambda jako argumentu 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

Uwagi

@No__t-0 to delegat metody lub wyrażenia lambda, które zwraca true, jeśli obiekt przeszedł do niego, dopasowuje warunki zdefiniowane w delegatze lub wyrażeniu 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. Elementy array są indywidualnie przenoszone do Predicate<T>, zaczynając od pierwszego elementu i kończąc z ostatnim elementem.The elements of array are individually passed to the Predicate<T>, starting with the first element and ending with the last element. Przetwarzanie jest zatrzymane po znalezieniu dopasowania.Processing is stopped when a match is found.

Ta metoda jest operacją O (n), gdzie n jest Length array.This method is an O(n) operation, where n is the Length of array.

Dotyczy

Zobacz też