Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Array.FindAll<T>(T[], Predicate<T>)

 

Publicado: octubre de 2016

Recupera todos los elementos que coinciden con las condiciones definidas por el predicado especificado.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

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

Parámetros

array
Type: T[]

Array unidimensional de base cero en la que se va a buscar.

match
Type: System.Predicate<T>

Predicate<T> que define las condiciones de los elementos que se van a buscar.

Valor devuelto

Type: T[]

Array que contiene todos los elementos que cumplen las condiciones definidas por el predicado especificado, si se encuentran; en caso contrario, devuelve una Array vacía.

Parámetros de tipo

T

Tipo de los elementos de la matriz.

Exception Condition
ArgumentNullException

El valor de array es null.

O bien

El valor de match es null.

El Predicate<T> es un delegado a un método que devuelve true si el objeto pasado a coincide con las condiciones definidas en el delegado. Los elementos de array se pasan individualmente a la Predicate<T>, y los elementos que cumplen las condiciones se guardan en la matriz devuelta.

Este método es una O (n) operación, donde n es el Length de array.

En el ejemplo siguiente se crea una matriz de números aleatorios 50 con valores que pueden oscilar entre 0 y 1000. A continuación, llama el FindAll<T> método con una expresión lambda que devuelve los valores de ese intervalo de 300 a 600. Tenga en cuenta que la expresión lambda se pasa un parámetro denominado x; Esto representa el miembro de la matriz individuales que se pasa a la Predicate<T>. Tenga en cuenta también que el equipo local lBound y uBound las variables son accesibles dentro de la expresión 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

En el ejemplo de código siguiente se muestra la Find<T>, FindLast<T>, y FindAll<T> métodos genéricos. Se crea una matriz de cadenas, que contiene 8 nombres de dinosaurio, dos de los cuales (en las posiciones 1 y 5) terminan en "saurus". El ejemplo de código también define un método de predicado de búsqueda denominado EndsWithSaurus, que acepta un parámetro de cadena y devuelve un valor booleano de valor que indica si la cadena de entrada termina en "saurus".

El Find<T> método genérico recorre la matriz desde el principio, pasando cada elemento a su vez a la EndsWithSaurus método. La búsqueda detiene cuando la EndsWithSaurus método true para el elemento "Amargasaurus".

System_CAPS_noteNota

En C# y Visual Basic, no es necesario crear la Predicate<string> delegar (Predicate(Of String) en Visual Basic) explícitamente. Estos lenguajes deducen al delegado correcto del contexto y lo crean automáticamente.

El FindLast<T> método genérico se usa para buscar en la matriz hacia atrás desde el final. Busca el elemento "Dilophosaurus" en la posición 5. El FindAll<T> método genérico se utiliza para devolver una matriz que contiene todos los elementos que terminan en "saurus". Se muestran los elementos.

El ejemplo de código también muestra la Exists<T> y TrueForAll<T> métodos genéricos.

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

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 2.0
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Windows Phone Silverlight
Disponible desde 8.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: