Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

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

 

Data di pubblicazione: ottobre 2016

Recupera tutti gli elementi che soddisfano le condizioni definite nel predicato specificato.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

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

Parametri

array
Type: T[]

Oggetto Array unidimensionale in base zero in cui eseguire la ricerca.

match
Type: System.Predicate<T>

Oggetto Predicate<T> che definisce le condizioni degli elementi da cercare.

Valore restituito

Type: T[]

Oggetto Array contenente tutti gli elementi che corrispondono alle condizioni definite dal predicato specificato, se presente; in caso contrario, un oggetto Array vuoto.

Parametri tipo

T

Tipo degli elementi della matrice.

Exception Condition
ArgumentNullException

array è null.

-oppure-

match è null.

Il Predicate<T> è un delegato a un metodo che restituisce true se l'oggetto passato a corrisponda alle condizioni definite nel delegato. Gli elementi di array vengono passati singolarmente per il Predicate<T>, e gli elementi che soddisfano le condizioni vengono salvati nella matrice restituita.

Questo metodo è un'operazione O (n) operazione, in cui n è il Length di array.

Nell'esempio seguente crea una matrice di numeri casuali 50 con i valori sono compresi tra 0 e 1000. Chiama quindi il FindAll<T> (metodo) con un'espressione lambda che restituisce i valori di intervallo compreso tra 300 su 600. Si noti che l'espressione lambda viene passata un parametro denominato x; rappresenta il membro di matrice singoli che viene passato per il Predicate<T>. Si noti inoltre che locale lBound e uBound le variabili sono accessibili all'interno dell'espressione lambda.

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

L'esempio di codice seguente illustra il Find<T>, FindLast<T>, e FindAll<T> metodi generici. Viene creata una matrice di stringhe contenente 8 dinosauro, due dei quali (in corrispondenza delle posizioni 1 e 5) terminano con "saurus". L'esempio di codice definisce anche un metodo di predicato di ricerca denominato EndsWithSaurus, che accetta un parametro di stringa e restituisce un valore booleano che indica se la stringa di input termina con "saurus".

Il Find<T> metodo generico consente di scorrere la matrice dall'inizio, passando a sua volta a ogni elemento di EndsWithSaurus metodo. La ricerca si interrompe quando il EndsWithSaurus restituisce true per l'elemento "Amargasaurus".

System_CAPS_noteNota

In c# e Visual Basic, non è necessario creare il Predicate<string> delegato (Predicate(Of String) in Visual Basic) in modo esplicito. Questi linguaggi deducono il delegato corretto dal contesto e creano automaticamente.

Il FindLast<T> metodo generico utilizzato per la ricerca della matrice con le versioni precedenti dalla fine. Trova l'elemento "Dilophosaurus" nella posizione 5. Il FindAll<T> metodo generico viene utilizzato per restituire una matrice contenente tutti gli elementi che terminano con "saurus". Gli elementi vengono visualizzati.

L'esempio di codice viene inoltre illustrato il Exists<T> e TrueForAll<T> metodi generici.

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

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 2.0
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Windows Phone Silverlight
Disponibile da 8.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: