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

Definition

Vyhledá prvek, který odpovídá podmínkám definovaných zadaným predikátem, a vrátí první výskyt v rámci celého 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

Type Parameters

T

Typ prvků pole.The type of the elements of the array.

Parameters

array
T[]

Jednorozměrné pole založené na nule, které má být prohledáno.The one-dimensional, zero-based array to search.

match
Predicate<T>

Predikát definující podmínky prvku, který má být hledán.The predicate that defines the conditions of the element to search for.

Returns

T

První prvek, který odpovídá podmínkám definovaným zadaným predikátem, pokud byl nalezen; jinak výchozí hodnota typu T.The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type T.

Exceptions

array je null.array is null.

-nebo--or- match je null.match is null.

Examples

Následující příklad používá delegáta Predicate<T> s obecnou Findou metodou pro hledání pole Point struktury.The following example uses a Predicate<T> delegate with the Find generic method to search an array of Point structures. Metoda, kterou delegát představuje, ProductGT10, vrátí true, pokud je součin polí X a Y větší než 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 volá delegáta pro každý prvek pole a vrátí první bod, který splňuje podmínku testu.The Find method calls the delegate for each element of the array, returning the first point that meets the test condition.

Note

Visual Basic a C# uživatelé nemusí explicitně vytvořit delegáta nebo zadat argument typu Obecné metody.Visual Basic and C# users do not have to create the delegate explicitly or specify the type argument of the generic method. Kompilátory určují nezbytné typy z argumentů metody, které zadáte.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

Namísto explicitního definování metody s nezbytným podpisem, vytvoření instance Predicate<T> delegáta a předání delegáta metodě Find, je vlastní pro použití výrazu 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. Následující příklad je stejný jako předchozí, s tím rozdílem, že používá výraz lambda jako 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

Remarks

Predicate<T> je delegátem metody nebo výrazu lambda, který vrací true, pokud předaný objekt odpovídá podmínkám definovaným ve výrazu Delegate nebo 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. Prvky array jsou jednotlivě předány do Predicate<T>, počínaje prvním prvkem a končí posledním prvkem.The elements of array are individually passed to the Predicate<T>, starting with the first element and ending with the last element. Zpracování se zastaví, když se najde shoda.Processing is stopped when a match is found.

Tato metoda je operace O (n), kde n je Length array.This method is an O(n) operation, where n is the Length of array.

Applies to

See also