Array.Exists<T>(T[], Predicate<T>) Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Bestimmt, ob das angegebene Array Elemente enthält, die mit den vom angegebenen Prädikat definierten Bedingungen übereinstimmen.
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> -> boolPublic Shared Function Exists(Of T) (array As T(), match As Predicate(Of T)) As BooleanTypparameter
- T
Der Typ der Elemente des Arrays.
Parameter
- array
- T[]
Das zu durchsuchende eindimensionale und nullbasierte Array.
- match
- Predicate<T>
Das Predicate<T>, das die Bedingungen für die Elemente definiert, nach denen gesucht werden soll.
Gibt zurück
true, wenn array mindestens ein Element enthält, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, andernfalls false.
Ausnahmen
Beispiele
Im folgenden Beispiel werden die Übereinstimmungsbedingungen für die Exists Methode mithilfe von Lambdaausdrücken angegeben, um zu überprüfen, ob ein Planet mit einem bestimmten Buchstaben beginnt oder ob der Planet auf dem angegebenen Array gefunden wird.
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
Im folgenden Beispiel wird die Exists Methode verwendet, um anzugeben, ob namen in einem Zeichenfolgenarray mit einem angegebenen Zeichen beginnen. Im Beispiel wird ein StringSearcher Objekt instanziiert, indem die Zeichenfolge übergeben wird, um an den Klassenkonstruktor zu suchen. Die StringSearcher.StartsWith Methode hat dieselbe Signatur wie die Predicate<T> Stellvertretung. Wenn die Exists Methode aufgerufen wird, wird jedes Element des Arrays an die Stellvertretung übergeben, bis es alle Elemente im Array zurückgibt true oder durchläuft.
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
Sie können auch einen Lambda-Ausdruck anstelle explizit definieren, deren Signatur der Stellvertretung entspricht. Im folgenden Beispiel wird die StringSearcher Klasse und ihre StartsWith Methode durch einen Lambda-Ausdruck ersetzt.
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
Hinweise
Dies Predicate<T> ist eine Stellvertretung an eine Methode, die zurückgibt true , wenn das an sie übergebene Objekt mit den in der Stellvertretung definierten Bedingungen übereinstimmt. Die Elemente werden array einzeln an das Predicate<T>Element übergeben, und die Verarbeitung wird beendet, wenn eine Übereinstimmung gefunden wird.
Hinweis
In C# und Visual Basic ist es nicht erforderlich, die Predicate<T> Stellvertretung explizit zu erstellen. Diese Sprachen ziehen die richtige Stellvertretung aus dem Kontext ab und erstellen sie automatisch. In F# werden Funktionen und Lambdaausdrücke implizit konvertiert.
Diese Methode ist ein O(n)-Vorgang, wobei n es sich um den Length Wert handelt array.