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 den vom angegebenen Prädikat definierten Bedingungen entsprechen.
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[]
Die eindimensionale, nullbasierte Array Suche.
- match
- Predicate<T>
Dies Predicate<T> definiert die Bedingungen der elemente, nach denen gesucht werden soll.
Gibt zurück
true wenn array ein oder mehrere Elemente enthalten sind, die den vom angegebenen Prädikat definierten Bedingungen entsprechen; andernfalls false.
Ausnahmen
Beispiele
Im folgenden Beispiel werden die Übereinstimmungsbedingungen für die Exists Methode mithilfe von Lambda-Ausdrücken angegeben, um zu überprüfen, ob ein Planet mit einem bestimmten Buchstaben beginnt oder ob der Planet im 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, nach der gesucht werden soll, an den Klassenkonstruktor. Die StringSearcher.StartsWith Methode hat dieselbe Signatur wie der Predicate<T> Delegat. Wenn die Exists Methode aufgerufen wird, wird jedes Element des Arrays an den Delegaten ü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 verwenden, anstatt explizit eine Methode zu definieren, deren Signatur der Stellvertretung entspricht. Im folgenden Beispiel wird die StringSearcher Klasse und die zugehörige 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 ein Delegat an eine Methode, die zurückgibt true , wenn das an sie übergebene Objekt den in der Stellvertretung definierten Bedingungen entspricht. Die Elemente werden array einzeln an das Element übergeben, und die Predicate<T>Verarbeitung wird beendet, wenn eine Übereinstimmung gefunden wird.
Note
In C# und Visual Basic ist es nicht erforderlich, den Predicate<T> Delegat explizit zu erstellen. In diesen Sprachen wird der richtige Delegat aus dem Kontext abgeleitet und automatisch erstellt. In F# werden Funktionen und Lambda-Ausdrücke implizit konvertiert.
Bei dieser Methode handelt es sich um einen O()-Vorgang, bei dem n es sich um einen n OLength(array)-Vorgang handelt.
