Export (0) Print
Expand All
3 out of 7 rated this helpful - Rate this topic

Array.Find<T> Method

Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire Array.

Namespace:  System
Assembly:  mscorlib (in mscorlib.dll)
public static T Find<T>(
	T[] array,
	Predicate<T> match
)

Type Parameters

T

The type of the elements of the array.

Parameters

array
Type: T[]

The one-dimensional, zero-based array to search.

match
Type: System.Predicate<T>

The predicate that defines the conditions of the element to search for.

Return Value

Type: T
The first element that matches the conditions defined by the specified predicate, if found; otherwise, the default value for type T.
ExceptionCondition
ArgumentNullException

array is null.

-or-

match is null.

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. The elements of array are individually passed to the Predicate<T>, starting with the first element and ending with the last element. Processing is stopped when a match is found.

This method is an O(n) operation, where n is the Length of array.

The following example uses a Predicate<T> delegate with the Find<T> generic method to search an array of Point structures. The method the delegate represents, ProductGT10, returns true if the product of the X and Y fields is greater than 100,000. The Find<T> method calls the delegate for each element of the array, returning the first point that meets the test condition.

NoteNote

Visual Basic and C# users do not have to create the delegate explicitly or specify the type argument of the generic method. The compilers determine the necessary types from the method arguments you supply.

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
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

Rather than explicitly defining a method with the necessary signature, instantiating a Predicate<T> delegate, and passing the delegate to the Find<T> method, it is customary to use a lambda expression. 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

.NET Framework

Supported in: 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Portable Class Library

Supported in: Portable Class Library

.NET for Windows Store apps

Supported in: Windows 8

.NET for Windows Phone apps

Supported in: Windows Phone 8.1, Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Server Core Role not supported), Windows Server 2008 R2 (Server Core Role supported with SP1 or later; Itanium not supported)

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.

Show:
© 2014 Microsoft. All rights reserved.