List<T>.FindIndex Metodo

Riferimento

Definizione

Spazio dei nomi:: System.Collections.Generic

Assembly:: System.Collections.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

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

Origine:: List.cs

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.

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

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

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

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".

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

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:

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

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

Vedi anche

Si applica a

FindIndex(Predicate<T>)

Origine:: List.cs

Origine:: List.cs

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>.

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

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

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

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".

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

Commenti

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

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

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

Vedi anche

Si applica a

FindIndex(Int32, Predicate<T>)

Origine:: List.cs

Origine:: List.cs

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.

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

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

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

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".

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

Commenti

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

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

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

Si applica a

Condividi tramite

List<T>.FindIndex Metodo

Definizione

Overload

FindIndex(Int32, Int32, Predicate<T>)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

FindIndex(Predicate<T>)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

FindIndex(Int32, Predicate<T>)

Parametri

Restituisce

Eccezioni

Esempio

Commenti

Vedi anche

Si applica a

Risorse aggiuntive