List<T>.FindIndex Método

Definición

Espacio de nombres:: System.Collections.Generic

Ensamblados:: mscorlib.dll, System.Collections.dll

Ensamblados:: netstandard.dll, System.Collections.dll

Ensamblado:: System.Collections.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Busca un elemento que coincida con las condiciones definidas por un predicado especificado y devuelve el índice de base cero de la primera aparición dentro de o List<T> una parte de él. Este método devuelve -1 si no se encuentra un elemento que coincida con las condiciones.

Sobrecargas

Nombre	Description
FindIndex(Int32, Int32, Predicate<T>)	Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición dentro del intervalo de elementos del List<T> que comienza en el índice especificado y contiene el número especificado de elementos.
FindIndex(Predicate<T>)	Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición dentro de todo List<T>.
FindIndex(Int32, Predicate<T>)	Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición dentro del intervalo de elementos del List<T> que se extiende desde el índice especificado hasta el último elemento.

FindIndex(Int32, Int32, Predicate<T>)

Source:: List.cs

Source:: List.cs

Source:: List.cs

Source:: List.cs

Source:: List.cs

Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición dentro del intervalo de elementos del List<T> que comienza en el índice especificado y contiene el número especificado de elementos.

public:
 int FindIndex(int startIndex, int count, Predicate<T> ^ match);

public int FindIndex(int startIndex, int count, Predicate<T> match);

member this.FindIndex : int * int * Predicate<'T> -> int

Public Function FindIndex (startIndex As Integer, count As Integer, match As Predicate(Of T)) As Integer

Parámetros

startIndex: Int32

Índice inicial de base cero de la búsqueda.

count: Int32

Número de elementos de la sección que se va a buscar.

match: Predicate<T>

Predicate<T> Delegado que define las condiciones del elemento que se van a buscar.

Devoluciones

Int32

Índice de base cero de la primera aparición de un elemento que coincide con las condiciones definidas por match, si se encuentra; de lo contrario, -1.

Excepciones

ArgumentNullException

match es null.

ArgumentOutOfRangeException

startIndexestá fuera del intervalo de índices válidos para .List<T>

O bien

count es menor que 0.

O bien

startIndexy count no especifican una sección válida en .List<T>

Ejemplos

En el ejemplo siguiente se define una Employee clase con dos campos y NameId . También define una EmployeeSearch clase con un único método, StartsWith, que indica si el Employee.Name campo comienza con una subcadena especificada que se proporciona al constructor de clase EmployeeSearch . Anote la firma de este método.

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

corresponde a la firma del delegado que se puede pasar al FindIndex método . En el ejemplo se crea una instancia de un List<Employee> objeto, se agrega un número de Employee objetos a él y, a continuación, se llama al FindIndex(Int32, Int32, Predicate<T>) método dos veces para buscar en toda la colección (es decir, los miembros del índice 0 al índice Count - 1). La primera vez, busca el primer Employee objeto cuyo Name campo comienza por "J"; la segunda vez, busca el primer Employee objeto cuyo Name campo comienza por "Ju".

using System;
using System.Collections.Generic;

public class Employee : IComparable
{
   public String Name { get; set; }
   public int Id { get; set; }

   public int CompareTo(Object o )
   {
      Employee e = o as Employee;
      if (e == null)
         throw new ArgumentException("o is not an Employee object.");

      return Name.CompareTo(e.Name);
   }
}

public class EmployeeSearch
{
   String _s;

   public EmployeeSearch(String s)
   {
      _s = s;
   }

   public bool StartsWith(Employee e)
   {
      return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase);
   }
}

public class Example
{
   public static void Main()
   {
      var employees = new List<Employee>();
      employees.AddRange( new Employee[] { new Employee { Name = "Frank", Id = 2 },
                                           new Employee { Name = "Jill", Id = 3 },
                                           new Employee { Name = "Dave", Id = 5 },
                                           new Employee { Name = "Jack", Id = 8 },
                                           new Employee { Name = "Judith", Id = 12 },
                                           new Employee { Name = "Robert", Id = 14 },
                                           new Employee { Name = "Adam", Id = 1 } } );
      employees.Sort();

      var es = new EmployeeSearch("J");
      Console.WriteLine("'J' starts at index {0}",
                        employees.FindIndex(0, employees.Count - 1, es.StartsWith));

      es = new EmployeeSearch("Ju");
      Console.WriteLine("'Ju' starts at index {0}",
                        employees.FindIndex(0, employees.Count - 1,es.StartsWith));
   }
}
// The example displays the following output:
//       'J' starts at index 3
//       'Ju' starts at index 5

Imports System.Collections.Generic

Public Class Employee : Implements IComparable
   Public Property Name As String
   Public Property Id As Integer
   
   Public Function CompareTo(o As Object) As Integer _
         Implements IComparable.CompareTo
      Dim e As Employee = TryCast(o, Employee)
      If e Is Nothing Then
         Throw New ArgumentException("o is not an Employee object.")
      End If

      Return Name.CompareTo(e.Name)
   End Function
End Class

Public Class EmployeeSearch
   Dim _s As String
   
   Public Sub New(s As String)
      _s = s
   End Sub
   
   Public Function StartsWith(e As Employee) As Boolean
      Return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase)
   End Function
End Class

Module Example
   Public Sub Main()
      Dim employees As New List(Of Employee)()
      employees.AddRange( { New Employee() With { .Name = "Frank", .Id = 2 },
                            New Employee() With { .Name = "Jill", .Id = 3 },
                            New Employee() With { .Name = "Dave", .Id = 5 },
                            New Employee() With { .Name = "Jack", .Id = 8 },
                            New Employee() With { .Name = "Judith", .Id = 12 },
                            New Employee() With { .Name = "Robert", .Id = 14 },
                            New Employee() With { .Name = "Adam", .Id = 1 } } )
      employees.Sort()

      Dim es As New EmployeeSearch("J")
      Console.WriteLine("'J' starts at index {0}",
                        employees.FindIndex(0, employees.Count - 1,
                                            AddressOf es.StartsWith))
      es = New EmployeeSearch("Ju")
      Console.WriteLine("'Ju' starts at index {0}",
                        employees.FindIndex(0, employees.Count - 1,
                                            AddressOf es.StartsWith))
   End Sub
End Module
' The example displays the following output:
'       'J' starts at index 3
'       'Ju' starts at index 5

Comentarios

List<T> Se busca a partir startIndex de y termina en startIndex más menos count 1, si count es mayor que 0.

Predicate<T> es un delegado a un método que devuelve true si el objeto pasado a él coincide con las condiciones definidas en el delegado. Los elementos del actual List<T> se pasan individualmente al Predicate<T> delegado. El delegado tiene la firma :

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Este método realiza una búsqueda lineal; por lo tanto, este método es una operación O(n), donde n es count.

Consulte también

Se aplica a

FindIndex(Predicate<T>)

Source:: List.cs

Source:: List.cs

Source:: List.cs

Source:: List.cs

Source:: List.cs

Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición dentro de todo List<T>.

public:
 int FindIndex(Predicate<T> ^ match);

public int FindIndex(Predicate<T> match);

member this.FindIndex : Predicate<'T> -> int

Public Function FindIndex (match As Predicate(Of T)) As Integer

Parámetros

match: Predicate<T>

Predicate<T> Delegado que define las condiciones del elemento que se van a buscar.

Devoluciones

Int32

Índice de base cero de la primera aparición de un elemento que coincide con las condiciones definidas por match, si se encuentra; de lo contrario, -1.

Excepciones

ArgumentNullException

match es null.

Ejemplos

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

corresponde a la firma del delegado que se puede pasar al FindIndex método . En el ejemplo se crea una instancia de un List<Employee> objeto, se agrega un número de Employee objetos a él y, a continuación, se llama al FindIndex(Int32, Int32, Predicate<T>) método dos veces para buscar en toda la colección, la primera vez para el primer Employee objeto cuyo Name campo comienza por "J" y la segunda vez para el primer Employee objeto cuyo Name campo comienza por "Ju".

using System;
using System.Collections.Generic;

public class Employee : IComparable
{
   public String Name { get; set; }
   public int Id { get; set; }

   public int CompareTo(Object o )
   {
      Employee e = o as Employee;
      if (e == null)
         throw new ArgumentException("o is not an Employee object.");

      return Name.CompareTo(e.Name);
   }
}

public class EmployeeSearch
{
   String _s;

   public EmployeeSearch(String s)
   {
      _s = s;
   }

   public bool StartsWith(Employee e)
   {
      return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase);
   }
}

public class Example
{
   public static void Main()
   {
      var employees = new List<Employee>();
      employees.AddRange( new Employee[] { new Employee { Name = "Frank", Id = 2 },
                                           new Employee { Name = "Jill", Id = 3 },
                                           new Employee { Name = "Dave", Id = 5 },
                                           new Employee { Name = "Jack", Id = 8 },
                                           new Employee { Name = "Judith", Id = 12 },
                                           new Employee { Name = "Robert", Id = 14 },
                                           new Employee { Name = "Adam", Id = 1 } } );
      employees.Sort();

      var es = new EmployeeSearch("J");
      Console.WriteLine("'J' starts at index {0}",
                        employees.FindIndex(es.StartsWith));

      es = new EmployeeSearch("Ju");
      Console.WriteLine("'Ju' starts at index {0}",
                        employees.FindIndex(es.StartsWith));
   }
}
// The example displays the following output:
//       'J' starts at index 3
//       'Ju' starts at index 5

Imports System.Collections.Generic

Public Class Employee : Implements IComparable
   Public Property Name As String
   Public Property Id As Integer
   
   Public Function CompareTo(o As Object) As Integer _
         Implements IComparable.CompareTo
      Dim e As Employee = TryCast(o, Employee)
      If e Is Nothing Then
         Throw New ArgumentException("o is not an Employee object.")
      End If

      Return Name.CompareTo(e.Name)
   End Function
End Class

Public Class EmployeeSearch
   Dim _s As String
   
   Public Sub New(s As String)
      _s = s
   End Sub
   
   Public Function StartsWith(e As Employee) As Boolean
      Return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase)
   End Function
End Class

Module Example
   Public Sub Main()
      Dim employees As New List(Of Employee)()
      employees.AddRange( { New Employee() With { .Name = "Frank", .Id = 2 },
                            New Employee() With { .Name = "Jill", .Id = 3 },
                            New Employee() With { .Name = "Dave", .Id = 5 },
                            New Employee() With { .Name = "Jack", .Id = 8 },
                            New Employee() With { .Name = "Judith", .Id = 12 },
                            New Employee() With { .Name = "Robert", .Id = 14 },
                            New Employee() With { .Name = "Adam", .Id = 1 } } )
      employees.Sort()

      Dim es As New EmployeeSearch("J")
      Console.WriteLine("'J' starts at index {0}",
                        employees.FindIndex(AddressOf es.StartsWith))
      es = New EmployeeSearch("Ju")
      Console.WriteLine("'Ju' starts at index {0}",
                        employees.FindIndex(AddressOf es.StartsWith))
   End Sub
End Module
' The example displays the following output:
'       'J' starts at index 3
'       'Ju' starts at index 5

Comentarios

List<T> Se busca hacia delante comenzando en el primer elemento y finalizando en el último elemento.

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Este método realiza una búsqueda lineal; por lo tanto, este método es una operación O(n), donde n es Count.

Consulte también

Se aplica a

FindIndex(Int32, Predicate<T>)

Source:: List.cs

Source:: List.cs

Source:: List.cs

Source:: List.cs

Source:: List.cs

Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición dentro del intervalo de elementos del List<T> que se extiende desde el índice especificado hasta el último elemento.

public:
 int FindIndex(int startIndex, Predicate<T> ^ match);

public int FindIndex(int startIndex, Predicate<T> match);

member this.FindIndex : int * Predicate<'T> -> int

Public Function FindIndex (startIndex As Integer, match As Predicate(Of T)) As Integer

Parámetros

startIndex: Int32

Índice inicial de base cero de la búsqueda.

match: Predicate<T>

Predicate<T> Delegado que define las condiciones del elemento que se van a buscar.

Devoluciones

Int32

Índice de base cero de la primera aparición de un elemento que coincide con las condiciones definidas por match, si se encuentra; de lo contrario, -1.

Excepciones

ArgumentNullException

match es null.

ArgumentOutOfRangeException

startIndexestá fuera del intervalo de índices válidos para .List<T>

Ejemplos

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

corresponde a la firma del delegado que se puede pasar al FindIndex método . En el ejemplo se crea una instancia de un List<Employee> objeto, se agrega un número de Employee objetos a él y, a continuación, se llama al FindIndex(Int32, Int32, Predicate<T>) método dos veces para buscar en la colección a partir de su quinto miembro (es decir, el miembro en el índice 4). La primera vez, busca el primer Employee objeto cuyo Name campo comienza por "J"; la segunda vez, busca el primer Employee objeto cuyo Name campo comienza por "Ju".

using System;
using System.Collections.Generic;

public class Employee : IComparable
{
   public String Name { get; set; }
   public int Id { get; set; }

   public int CompareTo(Object o )
   {
      Employee e = o as Employee;
      if (e == null)
         throw new ArgumentException("o is not an Employee object.");

      return Name.CompareTo(e.Name);
   }
}

public class EmployeeSearch
{
   String _s;

   public EmployeeSearch(String s)
   {
      _s = s;
   }

   public bool StartsWith(Employee e)
   {
      return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase);
   }
}

public class Example
{
   public static void Main()
   {
      var employees = new List<Employee>();
      employees.AddRange( new Employee[] { new Employee { Name = "Frank", Id = 2 },
                                           new Employee { Name = "Jill", Id = 3 },
                                           new Employee { Name = "Dave", Id = 5 },
                                           new Employee { Name = "Jack", Id = 8 },
                                           new Employee { Name = "Judith", Id = 12 },
                                           new Employee { Name = "Robert", Id = 14 },
                                           new Employee { Name = "Adam", Id = 1 } } );
      employees.Sort();

      var es = new EmployeeSearch("J");
      int index = employees.FindIndex(4, es.StartsWith);
      Console.WriteLine("Starting index of'J': {0}",
                        index >= 0 ? index.ToString() : "Not found");

      es = new EmployeeSearch("Ju");
      index = employees.FindIndex(4, es.StartsWith);
      Console.WriteLine("Starting index of 'Ju': {0}",
                        index >= 0 ? index.ToString() : "Not found");
   }
}
// The example displays the following output:
//       'J' starts at index 4
//       'Ju' starts at index 5

Imports System.Collections.Generic

Public Class Employee : Implements IComparable
   Public Property Name As String
   Public Property Id As Integer
   
   Public Function CompareTo(o As Object) As Integer _
         Implements IComparable.CompareTo
      Dim e As Employee = TryCast(o, Employee)
      If e Is Nothing Then
         Throw New ArgumentException("o is not an Employee object.")
      End If

      Return Name.CompareTo(e.Name)
   End Function
End Class

Public Class EmployeeSearch
   Dim _s As String
   
   Public Sub New(s As String)
      _s = s
   End Sub
   
   Public Function StartsWith(e As Employee) As Boolean
      Return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase)
   End Function
End Class

Module Example
   Public Sub Main()
      Dim employees As New List(Of Employee)()
      employees.AddRange( { New Employee() With { .Name = "Frank", .Id = 2 },
                            New Employee() With { .Name = "Jill", .Id = 3 },
                            New Employee() With { .Name = "Dave", .Id = 5 },
                            New Employee() With { .Name = "Jack", .Id = 8 },
                            New Employee() With { .Name = "Judith", .Id = 12 },
                            New Employee() With { .Name = "Robert", .Id = 14 },
                            New Employee() With { .Name = "Adam", .Id = 1 } } )
      employees.Sort()

      Dim es As New EmployeeSearch("J")
      Dim index As Integer = employees.FindIndex(4, AddressOf es.StartsWith)        
      Console.WriteLine("Starting index of'J': {0}",
                        If(index >= 0, index.ToString(), "Not found"))

      es = New EmployeeSearch("Ju")
      index = employees.FindIndex(4, AddressOf es.StartsWith) 
      Console.WriteLine("Starting index of'Ju': {0}",
                        If(index >= 0, index.ToString(), "Not found"))

   End Sub
End Module
' The example displays the following output:
'       'J' starts at index 4
'       'Ju' starts at index 5

Comentarios

List<T> Se busca hacia delante a partir startIndex de y finalizando en el último elemento.

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Este método realiza una búsqueda lineal; por lo tanto, este método es una operación O(n), donde n es el número de elementos de startIndex hasta el final de List<T>.

Consulte también

Se aplica a

Comentarios

¿Le ha resultado útil esta página?