List<T>.FindIndex Metodo

Definizione

Spazio dei nomi:

System.Collections.Generic

Assembly:

System.Collections.dll

Cerca un elemento che corrisponda alle condizioni definite da un predicato specificato e restituisce l'indice in base zero della prima occorrenza all'interno di List<T> o di una parte di esso. Questo metodo restituisce -1 se non viene trovato alcun articolo che soddisfa le condizioni.

Overload

FindIndex(Int32, Int32, Predicate<T>)	Cerca un elemento che soddisfi le condizioni definite dal predicato specificato e restituisce l'indice in base zero della prima occorrenza all'interno dell'intervallo di elementi nell'oggetto List<T> che inizia dall'indice specificato e contiene il numero indicato di elementi.
FindIndex(Predicate<T>)	Cerca un elemento che corrisponda alle condizioni definite dal predicato specificato e restituisce l'indice in base zero della prima occorrenza all'interno di List<T>.
FindIndex(Int32, Predicate<T>)	Cerca un elemento che soddisfi le condizioni definite dal predicato specificato e restituisce l'indice in base zero della prima occorrenza all'interno dell'intervallo di elementi nell'oggetto List<T> compreso tra l'indice specificato e l'ultimo elemento.

FindIndex(Int32, Int32, Predicate<T>)

Origine:

List.cs

Cerca un elemento che soddisfi le condizioni definite dal predicato specificato e restituisce l'indice in base zero della prima occorrenza all'interno dell'intervallo di elementi nell'oggetto List<T> che inizia dall'indice specificato e contiene il numero indicato di elementi.

C#

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

Parametri

startIndex

Int32

Indice iniziale in base zero della ricerca.

count

Int32

Numero di elementi nella sezione in cui eseguire la ricerca.

match

Predicate<T>

Delegato Predicate<T> che definisce le condizioni dell'elemento da cercare.

Restituisce

Int32

Indice in base zero della prima occorrenza di un elemento che corrisponde alle condizioni definite da match, se presente; in caso contrario, -1.

Eccezioni

ArgumentNullException

match è null.

ArgumentOutOfRangeException

startIndex non è compreso nell'intervallo di indici validi per List<T>.

-oppure-

count è minore di 0.

-oppure-

startIndex e count non specificano una sezione valida in List<T>.

Esempio

L'esempio seguente definisce una Employee classe con due campi e IdName . Definisce anche una EmployeeSearch classe con un singolo metodo, StartsWith, che indica se il Employee.Name campo inizia con una sottostringa specificata fornita al costruttore della EmployeeSearch classe. Si noti la firma di questo metodo

C#

public bool StartsWith(Employee e)

corrisponde alla firma del delegato che può essere passato al FindIndex metodo . Nell'esempio viene creata un'istanza di un List<Employee> oggetto , viene aggiunto un numero di Employee oggetti e quindi viene chiamato il FindIndex(Int32, Int32, Predicate<T>) metodo due volte per eseguire la ricerca nell'intera raccolta , ovvero i membri dall'indice 0 all'indice Count - 1. La prima volta cerca il primo Employee oggetto il cui Name campo inizia con "J"; la seconda volta cerca il primo Employee oggetto il cui Name campo inizia con "Ju".

C#

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

Commenti

L'oggetto List<T> viene cercato in avanti a partire da startIndex e termina con startIndex il segno più count meno 1, se count è maggiore di 0.

Predicate<T> è un delegato a un metodo che restituisce true se l'oggetto passato corrisponde alle condizioni definite nel delegato. Gli elementi dell'oggetto corrente List<T> vengono passati singolarmente al Predicate<T> delegato. Il delegato ha la firma:

C#

public bool methodName(T obj)

Questo metodo esegue una ricerca lineare; pertanto, questo metodo è un'operazione O(n), dove n è count.

Vedi anche

• Exists(Predicate<T>)
• Find(Predicate<T>)
• FindLast(Predicate<T>)
• FindAll(Predicate<T>)
• FindLastIndex
• BinarySearch
• IndexOf
• LastIndexOf
• Predicate<T>

FindIndex(Predicate<T>)

Origine:

List.cs

Cerca un elemento che corrisponda alle condizioni definite dal predicato specificato e restituisce l'indice in base zero della prima occorrenza all'interno di List<T>.

C#

public int FindIndex (Predicate<T> match);

Parametri

match

Predicate<T>

Delegato Predicate<T> che definisce le condizioni dell'elemento da cercare.

Restituisce

Int32

Indice in base zero della prima occorrenza di un elemento che corrisponde alle condizioni definite da match, se presente; in caso contrario, -1.

Eccezioni

ArgumentNullException

match è null.

Esempio

L'esempio seguente definisce una Employee classe con due campi e IdName . Definisce anche una EmployeeSearch classe con un singolo metodo, StartsWith, che indica se il Employee.Name campo inizia con una sottostringa specificata fornita al costruttore della EmployeeSearch classe. Si noti la firma di questo metodo

C#

public bool StartsWith(Employee e)

corrisponde alla firma del delegato che può essere passato al FindIndex metodo . Nell'esempio viene creata un'istanza di un List<Employee> oggetto , viene aggiunto un numero di Employee oggetti e quindi viene chiamato il FindIndex(Int32, Int32, Predicate<T>) metodo due volte per eseguire la ricerca nell'intera raccolta, la prima volta per il primo Employee oggetto il cui Name campo inizia con "J" e la seconda volta per il primo Employee oggetto il cui Name campo inizia con "Ju".

C#

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

Commenti

L'oggetto List<T> viene cercato in avanti a partire dal primo elemento e termina con l'ultimo elemento.

Predicate<T> è un delegato a un metodo che restituisce true se l'oggetto passato corrisponde alle condizioni definite nel delegato. Gli elementi dell'oggetto corrente List<T> vengono passati singolarmente al Predicate<T> delegato. Il delegato ha la firma:

C#

public bool methodName(T obj)

Questo metodo esegue una ricerca lineare; pertanto, questo metodo è un'operazione O(n), dove n è Count.

Vedi anche

• Exists(Predicate<T>)
• Find(Predicate<T>)
• FindLast(Predicate<T>)
• FindAll(Predicate<T>)
• FindLastIndex
• BinarySearch
• IndexOf
• LastIndexOf
• Predicate<T>

FindIndex(Int32, Predicate<T>)

Origine:

List.cs

Cerca un elemento che soddisfi le condizioni definite dal predicato specificato e restituisce l'indice in base zero della prima occorrenza all'interno dell'intervallo di elementi nell'oggetto List<T> compreso tra l'indice specificato e l'ultimo elemento.

C#

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

Parametri

startIndex

Int32

Indice iniziale in base zero della ricerca.

match

Predicate<T>

Delegato Predicate<T> che definisce le condizioni dell'elemento da cercare.

Restituisce

Int32

Indice in base zero della prima occorrenza di un elemento che corrisponde alle condizioni definite da match, se presente; in caso contrario, -1.

Eccezioni

ArgumentNullException

match è null.

ArgumentOutOfRangeException

startIndex non è compreso nell'intervallo di indici validi per List<T>.

Esempio

L'esempio seguente definisce una Employee classe con due campi e IdName . Definisce anche una EmployeeSearch classe con un singolo metodo, StartsWith, che indica se il Employee.Name campo inizia con una sottostringa specificata fornita al costruttore della EmployeeSearch classe. Si noti la firma di questo metodo

C#

public bool StartsWith(Employee e)

corrisponde alla firma del delegato che può essere passato al FindIndex metodo . Nell'esempio viene creata un'istanza di un List<Employee> oggetto , viene aggiunto un numero di Employee oggetti e quindi viene chiamato il FindIndex(Int32, Int32, Predicate<T>) metodo due volte per eseguire una ricerca nell'insieme a partire dal quinto membro in corrispondenza dell'indice 4. La prima volta cerca il primo Employee oggetto il cui Name campo inizia con "J"; la seconda volta cerca il primo Employee oggetto il cui Name campo inizia con "Ju".

C#

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

Commenti

L'oggetto List<T> viene cercato in avanti a partire da startIndex e termina con l'ultimo elemento.

Predicate<T> è un delegato a un metodo che restituisce true se l'oggetto passato corrisponde alle condizioni definite nel delegato. Gli elementi dell'oggetto corrente List<T> vengono passati singolarmente al Predicate<T> delegato. Il delegato ha la firma:

C#

public bool methodName(T obj)

Questo metodo esegue una ricerca lineare; pertanto, questo metodo è un'operazione O(n), dove n è il numero di elementi da startIndex alla fine di List<T>.

Vedi anche

• Exists(Predicate<T>)
• Find(Predicate<T>)
• FindLast(Predicate<T>)
• FindAll(Predicate<T>)
• FindLastIndex
• BinarySearch
• IndexOf
• LastIndexOf
• Predicate<T>