Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

Array.Find<T> (Método)

Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve la primera aparición en toda la matriz Array.

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

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

Parámetros de tipo

T

Tipo de los elementos de la matriz.

Parámetros

array
Tipo: T[]
La matriz unidimensional, cero- basado para buscar.
match
Tipo: System.Predicate<T>
El predicado que define las condiciones del elemento para buscar.

Valor devuelto

Tipo: T
Primer elemento que coincide con las condiciones definidas por el predicado especificado, si se encuentra; de lo contrario, valor predeterminado para el tipo T.

ExcepciónCondición
ArgumentNullException

array es null.

O bien

match es null.

Predicate<T> es un delegado a un método o una expresión lambda que devuelve true si el objeto pasado a las condiciones definidas en el delegado o la expresión lambda. Los elementos de array se pasan individualmente a Predicate<T>, empezando por el primer elemento y termina con el último elemento. El procesamiento se detiene cuando se encuentra una coincidencia.

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

El ejemplo siguiente utiliza un delegado de Predicate<T> con el método genérico de Find<T> para buscar una matriz de estructuras de Point . El método que representa el delegado, ProductGT10, devuelve true si el producto de los campos X e Y es mayor que 100.000. El método Find<T> llama al delegado de cada elemento de la matriz, devolviendo el primer punto que cumple la condición de prueba.

NotaNota

Los usuarios de Visual Basic y C# no tienen que crear el delegado explícitamente o especificar el argumento de tipo del método genérico. Los compiladores determinan los tipos necesarios a partir de los argumentos de método que se suministren.


Imports System.Drawing

Public Module Example
   Public Sub Main()
      ' Create an array of five Point structures.
      Dim points() As Point = { new Point(100, 200), _
            new Point(150, 250), new Point(250, 375), _
            new Point(275, 395), new Point(295, 450) }

      ' Find the first Point structure for which X times Y 
      ' is greater than 100000. 
      Dim first As Point = Array.Find(points, 
                                      Function(p) p.X * p.Y > 100000)

      ' Display the first structure found.
      Console.WriteLine("Found: X = {0}, Y = {1}", _
            first.X, first.Y)
   End Sub
End Module
' The example displays the following output:
'       Found: X = 275, Y = 395



using System;
using System.Drawing;

public class Example
{
    public static void Main()
    {
        // Create an array of five Point structures.
        Point[] points = { new Point(100, 200), 
            new Point(150, 250), new Point(250, 375), 
            new Point(275, 395), new Point(295, 450) };

        // Find the first Point structure for which X times Y 
        // is greater than 100000. 
        Point first = Array.Find(points, ProductGT10);

        // Display the first structure found.
        Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y);
    }

    // Return true if X times Y is greater than 100000.
    private static bool ProductGT10(Point p)
    {
        return p.X * p.Y > 100000;
    }
}
// The example displays the following output:
//       Found: X = 275, Y = 395


En lugar de explícitamente definiendo un método con la firma necesaria, creando instancias de un delegado de Predicate<T> , y pasando el delegado al método de Find<T> , es habitual utilizar una expresión lambda. El ejemplo siguiente es idéntico al anterior, pero utiliza una expresión lambda como argumento de match .


using System;
using System.Drawing;

public class Example
{
    public static void Main()
    {
        // Create an array of five Point structures.
        Point[] points = { new Point(100, 200), 
            new Point(150, 250), new Point(250, 375), 
            new Point(275, 395), new Point(295, 450) };

        // Find the first Point structure for which X times Y 
        // is greater than 100000. 
        Point first = Array.Find(points, p => p.X * p.Y > 100000);

        // Display the first structure found.
        Console.WriteLine("Found: X = {0}, Y = {1}", first.X, first.Y);
    }
}
// The example displays the following output:
//       Found: X = 275, Y = 395


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2015 Microsoft