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

public:
generic <typename T>
 static bool Exists(cli::array <T> ^ array, Predicate<T> ^ match);

public static bool Exists<T>(T[] array, Predicate<T> match);

static member Exists : 'T[] * Predicate<'T> -> bool

Public Shared Function Exists(Of T) (array As T(), match As Predicate(Of T)) As Boolean

Type Parameters

Parameters

Returns

true if array contains one or more elements that match the conditions defined by the specified predicate; otherwise, false.

Exceptions

Examples

The following example specifies the match conditions for the Exists method using lambda expressions to check whether a planet starts with a given letter or whether the planet is found on the given array.

using System;

namespace Example
{
 class Program
 {
 static void Main(string[] args)
 {
 string[] planets = { "Mercury", "Venus",
 "Earth", "Mars", "Jupiter",
 "Saturn", "Uranus", "Neptune" };

 Console.WriteLine("One or more planets begin with 'M': {0}",
 Array.Exists(planets, element => element.StartsWith("M")));

 Console.WriteLine("One or more planets begin with 'T': {0}",
 Array.Exists(planets, element => element.StartsWith("T")));

 Console.WriteLine("Is Pluto one of the planets? {0}",
 Array.Exists(planets, element => element == "Pluto"));
 }
 }
}
// The example displays the following output:
// One or more planets begin with 'M': True
// One or more planets begin with 'T': False
// Is Pluto one of the planets? False

open System

let planets = 
 [| "Mercury"; "Venus"
 "Earth"; "Mars"; "Jupiter"
 "Saturn"; "Uranus"; "Neptune" |]

Array.Exists(planets, fun element -> element.StartsWith "M")
|> printfn "One or more planets begin with 'M': %O"

Array.Exists(planets, fun element -> element.StartsWith "T")
|> printfn "One or more planets begin with 'T': %O"

Array.Exists(planets, fun element -> element = "Pluto")
|> printfn "Is Pluto one of the planets? %O"

// The example displays the following output:
// One or more planets begin with 'M': True
// One or more planets begin with 'T': False
// Is Pluto one of the planets? False

Module Example
 Public Sub Main()
 Dim planets() As String = {"Mercury", "Venus",
 "Earth", "Mars", "Jupiter",
 "Saturn", "Uranus", "Neptune"}

 Console.WriteLine("One or more planets begin with 'M': {0}",
 Array.Exists(planets, Function(element)
 Return element.StartsWith("M")
 End Function))

 Console.WriteLine("One or more planets begin with 'T': {0}",
 Array.Exists(planets, Function(element)
 Return element.StartsWith("T")
 End Function))

 Console.WriteLine("Is Pluto one of the planets? {0}",
 Array.Exists(planets, Function(element)
 Return element.Equals("Pluto")
 End Function))

 End Sub
End Module
' The example displays the following output:
' One or more planets begin with 'M': True
' One or more planets begin with 'T': False
' Is Pluto one of the planets? False

The following example uses the Exists method to indicate whether any names in a string array begin with a specified character. The example instantiates a StringSearcher object by passing the string to search for to its class constructor. The StringSearcher.StartsWith method has same signature as the Predicate<T> delegate. When the Exists method is called, each member of the array is passed to the delegate until it returns true or iterates all the elements in the array.

using System;

public class Example
{
 public static void Main()
 {
 String[] names = { "Adam", "Adel", "Bridgette", "Carla",
 "Charles", "Daniel", "Elaine", "Frances",
 "George", "Gillian", "Henry", "Irving",
 "James", "Janae", "Lawrence", "Miguel",
 "Nicole", "Oliver", "Paula", "Robert",
 "Stephen", "Thomas", "Vanessa",
 "Veronica", "Wilberforce" };
 Char[] charsToFind = { 'A', 'K', 'W', 'Z' };

 foreach (var charToFind in charsToFind)
 Console.WriteLine("One or more names begin with '{0}': {1}",
 charToFind,
 Array.Exists(names, (new StringSearcher(charToFind)).StartsWith));
 }
}

public class StringSearcher
{
 char firstChar;

 public StringSearcher(char firstChar)
 {
 this.firstChar = char.ToUpper(firstChar);
 }

 public bool StartsWith(string s)
 {
 if (string.IsNullOrEmpty(s)) return false;

 if(s.Substring(0, 1).ToUpper() == firstChar.ToString())
 return true;
 else
 return false;
 }
}
// The example displays the following output:
// One or more names begin with 'A': True
// One or more names begin with 'K': False
// One or more names begin with 'W': True
// One or more names begin with 'Z': False

open System

type StringSearcher(firstChar) =
 member _.StartsWith(s) =
 if String.IsNullOrEmpty s then 
 false 
 else
 s.Substring(0, 1).ToUpper() = string firstChar

let names = 
 [| "Adam"; "Adel"; "Bridgette"; "Carla";
 "Charles"; "Daniel"; "Elaine"; "Frances"
 "George"; "Gillian"; "Henry"; "Irving"
 "James"; "Janae"; "Lawrence"; "Miguel"
 "Nicole"; "Oliver"; "Paula"; "Robert"
 "Stephen"; "Thomas"; "Vanessa"
 "Veronica"; "Wilberforce" |]

let charsToFind = [ 'A'; 'K'; 'W'; 'Z' ]

for char in charsToFind do 
 let exists = Array.Exists(names, fun x -> StringSearcher(char).StartsWith x)
 // let exists = Array.exists (StringSearcher(char).StartsWith) names
 printfn $"One or more names begin with '{char}': {exists}"

// The example displays the following output:
// One or more names begin with 'A': True
// One or more names begin with 'K': False
// One or more names begin with 'W': True
// One or more names begin with 'Z': False

Module Example
 Public Sub Main()
 Dim names() As String = { "Adam", "Adel", "Bridgette", "Carla",
 "Charles", "Daniel", "Elaine", "Frances",
 "George", "Gillian", "Henry", "Irving",
 "James", "Janae", "Lawrence", "Miguel",
 "Nicole", "Oliver", "Paula", "Robert",
 "Stephen", "Thomas", "Vanessa",
 "Veronica", "Wilberforce" }
 Dim charsToFind() As Char = { "A"c, "K"c, "W"c, "Z"c }
 
 For Each charToFind In charsToFind
 Console.WriteLine("One or more names begin with '{0}': {1}",
 charToFind,
 Array.Exists(names, AddressOf (New StringSearcher(charToFind)).StartsWith))
 Next
 End Sub
 
End Module

Public Class StringSearcher
 Dim firstChar As Char
 
 Public Sub New(firstChar As Char)
 Me.firstChar = Char.ToUpper(firstChar)
 End Sub
 
 Public Function StartsWith(s As String) As Boolean
 If String.IsNullOrEmpty(s) Then Return False
 
 If s.Substring(0, 1).ToUpper = firstChar Then
 Return True
 Else
 Return False
 End If
 End Function
End Class
' The example displays the following output:
' One or more names begin with 'A': True
' One or more names begin with 'K': False
' One or more names begin with 'W': True
' One or more names begin with 'Z': False

You can also use a lambda expression rather than explicitly define a method whose signature corresponds to that of the delegate. The following example replaces the StringSearcher class and its StartsWith method with a lambda expression.

using System;

public class Example
{
 public static void Main()
 {
 String[] names = { "Adam", "Adel", "Bridgette", "Carla",
 "Charles", "Daniel", "Elaine", "Frances",
 "George", "Gillian", "Henry", "Irving",
 "James", "Janae", "Lawrence", "Miguel",
 "Nicole", "Oliver", "Paula", "Robert",
 "Stephen", "Thomas", "Vanessa",
 "Veronica", "Wilberforce" };
 Char[] charsToFind = { 'A', 'K', 'W', 'Z' };

 foreach (var charToFind in charsToFind)
 Console.WriteLine("One or more names begin with '{0}': {1}",
 charToFind,
 Array.Exists(names,
 s => { if (string.IsNullOrEmpty(s))
 return false;

 if (s.Substring(0, 1).ToUpper() == charToFind.ToString())
 return true;
 else
 return false;
 } ));
 }
}
// The example displays the following output:
// One or more names begin with 'A': True
// One or more names begin with 'K': False
// One or more names begin with 'W': True
// One or more names begin with 'Z': False

open System

let names = 
 [| "Adam"; "Adel"; "Bridgette"; "Carla";
 "Charles"; "Daniel"; "Elaine"; "Frances"
 "George"; "Gillian"; "Henry"; "Irving"
 "James"; "Janae"; "Lawrence"; "Miguel"
 "Nicole"; "Oliver"; "Paula"; "Robert"
 "Stephen"; "Thomas"; "Vanessa"
 "Veronica"; "Wilberforce" |]

let charsToFind = [ 'A'; 'K'; 'W'; 'Z' ]

for char in charsToFind do
 let exists = 
 Array.Exists(names, fun s -> 
 if String.IsNullOrEmpty s then false 
 else s.Substring(0, 1).ToUpper() = string char)

 printfn $"One or more names begin with '{char}': {exists}"
 
// The example displays the following output:
// One or more names begin with 'A': True
// One or more names begin with 'K': False
// One or more names begin with 'W': True
// One or more names begin with 'Z': False

Module Example
 Public Sub Main()
 Dim names() As String = { "Adam", "Adel", "Bridgette", "Carla",
 "Charles", "Daniel", "Elaine", "Frances",
 "George", "Gillian", "Henry", "Irving",
 "James", "Janae", "Lawrence", "Miguel",
 "Nicole", "Oliver", "Paula", "Robert",
 "Stephen", "Thomas", "Vanessa",
 "Veronica", "Wilberforce" }
 Dim charsToFind() As Char = { "A"c, "K"c, "W"c, "Z"c }

 For Each charToFind In charsToFind
 Console.WriteLine("One or more names begin with '{0}': {1}",
 charToFind,
 Array.Exists(names, Function(s)
 If String.IsNullOrEmpty(s) Then Return False

 If s.Substring(0, 1).ToUpper = charToFind Then
 Return True
 Else
 Return False
 End If
 End Function ))
 Next
 End Sub
End Module
' The example displays the following output:
' One or more names begin with 'A': True
' One or more names begin with 'K': False
' One or more names begin with 'W': True
' One or more names begin with 'Z': False

Remarks

The Predicate<T> is a delegate to a method that returns true if the object passed to it matches the conditions defined in the delegate. The elements of array are individually passed to the Predicate<T>, and processing is stopped when a match is found.

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

See also

• Find<T>(T[], Predicate<T>)
• FindLast<T>(T[], Predicate<T>)
• FindAll<T>(T[], Predicate<T>)
• BinarySearch
• IndexOf
• LastIndexOf
• TrueForAll<T>(T[], Predicate<T>)
• Predicate<T>
• Lambda Expressions (C# Programming Guide)
• Lambda Expressions (Visual Basic)