Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Array.FindAll<T>-Methode: (T[], Predicate<T>)

 

Veröffentlicht: Oktober 2016

Ruft alle Elemente ab, die die vom angegebenen Prädikat definierten Bedingungen erfüllen.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

public static T[] FindAll<T>(
	T[] array,
	Predicate<T> match
)

Parameter

array
Type: T[]

Das zu durchsuchende eindimensionale und nullbasierte Array.

match
Type: System.Predicate<T>

Das Predicate<T>, das die Bedingungen für die Elemente definiert, nach denen gesucht werden soll.

Rückgabewert

Type: T[]

Ein Array mit allen Elementen, die ggf. die durch das angegebene Prädikat definierten Bedingungen erfüllen, andernfalls ein leeres Array.

Typparameter

T

Der Typ der Elemente des Arrays.

Exception Condition
ArgumentNullException

array ist null.

- oder -

match ist null.

Die Predicate<T> ist ein Delegat an eine Methode, die zurückgibt true an das Objekt übergeben sie die Bedingungen definiert, die im Delegaten übereinstimmt. Die Elemente der array einzeln übergeben werden, um die Predicate<T>, und Elemente, die Bedingungen erfüllen, werden im zurückgegebenen Array gespeichert.

Diese Methode ist eine O (n)-Vorgang, in dem n ist die Length von array.

Das folgende Beispiel erstellt ein Array von 50 zufälligen Zahlen mit Werten, die zwischen 0 und 1000 liegen können. Er ruft dann die FindAll<T> Methode mit einem Lambda-Ausdruck, der die Werte von 300 auf 600 dieses Bereichs zurückgibt. Beachten Sie, dass der Lambda-Ausdruck einen Parameter namens übergeben wird x; Dies stellt der einzelnen Arraymember, die an die Predicate<T>. Beachten Sie, dass die lokale lBound und uBound Variablen innerhalb der Lambda-Ausdruck zugegriffen werden.

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      // Get an array of n random integers.
      int[] values = GetArray(50, 0, 1000);
      int lBound = 300;
      int uBound = 600;
      int[] matchedItems = Array.FindAll(values, x =>  
                                       x >= lBound && x <= uBound);  
      for (int ctr = 0; ctr < matchedItems.Length; ctr++) {
         Console.Write("{0}  ", matchedItems[ctr]);
         if ((ctr + 1) % 12 == 0)
            Console.WriteLine();
      }
   }

   private static int[] GetArray(int n, int lower, int upper)
   {
      Random rnd = new Random();
      List<int> list = new List<int>();
      for (int ctr = 1; ctr <= n; ctr++)
         list.Add(rnd.Next(lower, upper + 1));

      return list.ToArray();
   }
}
// The example displays output similar to the following:
//       542  398  356  351  348  301  562  599  575  400  569  306
//       535  416  393  385

Das folgende Codebeispiel veranschaulicht die Find<T>, FindLast<T>, und FindAll<T> generische Methoden. Ein Array von Zeichenfolgen wird erstellt, 8, Dinosauriernamen enthält, von denen zwei (an Position 1 und 5) mit "Saurus" enden. Das Codebeispiel definiert auch eine Prädikat Search-Methode, die mit dem Namen EndsWithSaurus, der einen Zeichenfolgenparameter akzeptiert und einen booleschen Wert zurückgibt, der angibt, ob die Eingabezeichenfolge "Saurus" endet.

Die Find<T> generische Methode durchläuft das Array von Anfang an und übergibt die einzelnen Elemente an die EndsWithSaurus Methode. Die Suche angehalten wird, wenn die EndsWithSaurus -Methode zurückkehrt true für das Element "Amargasaurus".

System_CAPS_noteHinweis

In c# und Visual Basic, ist es nicht erforderlich, erstellen Sie die Predicate<string> delegieren (Predicate(Of String) in Visual Basic) explizit. Diese Sprachen leiten den richtigen Delegaten aus Kontext und automatisch zu erstellen.

Die FindLast<T> generische Methode wird verwendet, um das Array aus dem Ende rückwärts zu suchen. Es sucht nach dem Element "Dilophosaurus" an Position 5. Die FindAll<T> generische Methode wird verwendet, um ein Array mit allen Elementen, die auf "Saurus" enden zurückgeben. Die Elemente werden angezeigt.

Im Codebeispiel wird veranschaulicht, die auch die Exists<T> und TrueForAll<T> generische Methoden.

using System;

public class DinoDiscoverySet
{
    public static void Main()
    {
        string[] dinosaurs =
        {
            "Compsognathus", "Amargasaurus", "Oviraptor",
            "Velociraptor",  "Deinonychus",  "Dilophosaurus",
            "Gallimimus",    "Triceratops"
        };

        DinoDiscoverySet GoMesozoic = new DinoDiscoverySet(dinosaurs);

        GoMesozoic.DiscoverAll();
        GoMesozoic.DiscoverByEnding("saurus");
    }

    private string[] dinosaurs;

    public DinoDiscoverySet(string[] items)
    {
        dinosaurs = items;
    }

    public void DiscoverAll()
    {
        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }
    }

    public void DiscoverByEnding(string Ending)
    {
        Predicate<string> dinoType;

        switch (Ending.ToLower())
        {
            case "raptor":
                dinoType = EndsWithRaptor;
                break;
            case "tops":
                dinoType = EndsWithTops;
                break;
            case "saurus":
            default:
                dinoType = EndsWithSaurus;
                break;
        }
        Console.WriteLine(
            "\nArray.Exists(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array.Exists(dinosaurs, dinoType));

        Console.WriteLine(
            "\nArray.TrueForAll(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array.TrueForAll(dinosaurs, dinoType));

        Console.WriteLine(
            "\nArray.Find(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array.Find(dinosaurs, dinoType));

        Console.WriteLine(
            "\nArray.FindLast(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array.FindLast(dinosaurs, dinoType));

        Console.WriteLine(
            "\nArray.FindAll(dinosaurs, \"{0}\"):", Ending);

        string[] subArray =
            Array.FindAll(dinosaurs, dinoType);

        foreach(string dinosaur in subArray)
        {
            Console.WriteLine(dinosaur);
        }
    }

    // Search predicate returns true if a string ends in "saurus".
    private bool EndsWithSaurus(string s)
    {
        if ((s.Length > 5) &&
            (s.Substring(s.Length - 6).ToLower() == "saurus"))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    // Search predicate returns true if a string ends in "raptor".
    private bool EndsWithRaptor(String s)
    {
        if ((s.Length > 5) &&
            (s.Substring(s.Length - 6).ToLower() == "raptor"))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    // Search predicate returns true if a string ends in "tops".
    private bool EndsWithTops(String s)
    {
        if ((s.Length > 3) &&
            (s.Substring(s.Length - 4).ToLower() == "tops"))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

/* This code example produces the following output:

Compsognathus
Amargasaurus
Oviraptor
Velociraptor
Deinonychus
Dilophosaurus
Gallimimus
Triceratops

Array.Exists(dinosaurs, "saurus"): True

Array.TrueForAll(dinosaurs, "saurus"): False

Array.Find(dinosaurs, "saurus"): Amargasaurus

Array.FindLast(dinosaurs, "saurus"): Dilophosaurus

Array.FindAll(dinosaurs, "saurus"):
Amargasaurus
Dilophosaurus
*/

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 2.0
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Windows Phone Silverlight
Verfügbar seit 8.0
Windows Phone
Verfügbar seit 8.1
Zurück zum Anfang
Anzeigen: