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

Definition

Namespace:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Quelle:

Array.cs

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

C#

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

Typparameter

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

T[]

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

Ausnahmen

ArgumentNullException

array ist null.

- oder -

match ist null.

Beispiele

Im folgenden Beispiel wird ein Array von 50 Zufallszahlen mit Werten erstellt, die zwischen 0 und 1.000 liegen können. Anschließend wird die FindAll -Methode mit einem Lambdaausdruck aufgerufen, der die Werte zwischen 300 und 600 zurückgibt. Beachten Sie, dass dem Lambdaausdruck ein Parameter mit dem Namen xübergeben wird. Dieser stellt den einzelnen Arraymember dar, der an den Predicate<T>übergeben wird. Beachten Sie außerdem, dass auf die lokalen lBound Variablen und uBound innerhalb des Lambdaausdrucks zugegriffen werden kann.

C#

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

Im folgenden Codebeispiel werden die Findgenerischen Methoden , FindLastund FindAll veranschaulicht. Es wird ein Array von Zeichenfolgen erstellt, das 8 Dinosauriernamen enthält, von denen zwei (an Position 1 und 5) mit "saurus" enden. Das Codebeispiel definiert auch eine Suchprädikatmethode namens EndsWithSaurus, die einen Zeichenfolgenparameter akzeptiert und einen booleschen Wert zurückgibt, der angibt, ob die Eingabezeichenfolge auf "saurus" endet.

Die Find generische Methode durchläuft das Array von Anfang an und übergibt jedes Element nacheinander an die EndsWithSaurus -Methode. Die Suche wird beendet, wenn die EndsWithSaurus Methode das Element "Amargasaurus" zurückgibt true .

Hinweis

In C#, F# und Visual Basic ist es nicht erforderlich, den Predicate<string> Delegaten (Predicate(Of String) in Visual Basic) explizit zu erstellen. Diese Sprachen leiten den richtigen Delegat aus dem Kontext ab und erstellen ihn automatisch.

Die FindLast generische Methode wird verwendet, um das Array rückwärts vom Ende aus zu durchsuchen. Es findet das Element "Dilophosaurus" an Position 5. Die FindAll generische Methode wird verwendet, um ein Array zurückzugeben, das alle Elemente enthält, die auf "saurus" enden. Die Elemente werden angezeigt.

Im Codebeispiel werden auch die Exists generischen Methoden und TrueForAll veranschaulicht.

C#

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

Hinweise

Der Predicate<T> ist ein Delegat an eine Methode, die zurückgibt true , wenn das an sie übergebene Objekt den im Delegaten definierten Bedingungen entspricht. Die Elemente von array werden einzeln an das Predicate<T>übergeben, und die Elemente, die den Bedingungen entsprechen, werden im zurückgegebenen Array gespeichert.

Diese Methode ist ein O(n)-Vorgang, wobei n der Length von arrayist.

In F# kann stattdessen die Funktion Array.filter verwendet werden.

Gilt für:

Weitere Informationen

• Exists<T>(T[], Predicate<T>)
• Find<T>(T[], Predicate<T>)
• FindLast<T>(T[], Predicate<T>)
• BinarySearch
• IndexOf
• LastIndexOf
• Predicate<T>