List<T>.FindIndex Methode

Definitie

Naamruimte:: System.Collections.Generic

Assembly's:: mscorlib.dll, System.Collections.dll

Assembly:: mscorlib.dll

Assembly:: System.Collections.dll

Assembly:: netstandard.dll

Belangrijk

Bepaalde informatie heeft betrekking op een voorlopige productversie die aanzienlijk kan worden gewijzigd voordat deze wordt uitgebracht. Microsoft biedt geen enkele expliciete of impliciete garanties met betrekking tot de informatie die hier wordt verstrekt.

Zoekt naar een element dat overeenkomt met de voorwaarden die zijn gedefinieerd door een opgegeven predicaat en retourneert de op nul gebaseerde index van het eerste exemplaar binnen of List<T> een deel ervan. Deze methode retourneert -1 als een item dat overeenkomt met de voorwaarden niet wordt gevonden.

Overloads

Name	Description
FindIndex(Predicate<T>)	Zoekt naar een element dat overeenkomt met de voorwaarden die zijn gedefinieerd door het opgegeven predicaat en retourneert de op nul gebaseerde index van het eerste exemplaar binnen het hele List<T>exemplaar.
FindIndex(Int32, Predicate<T>)	Zoekt naar een element dat overeenkomt met de voorwaarden die zijn gedefinieerd door het opgegeven predicaat en retourneert de op nul gebaseerde index van het eerste exemplaar binnen het bereik van elementen in de List<T> opgegeven index tot het laatste element.
FindIndex(Int32, Int32, Predicate<T>)	Zoekt naar een element dat overeenkomt met de voorwaarden die zijn gedefinieerd door het opgegeven predicaat en retourneert de op nul gebaseerde index van het eerste exemplaar binnen het bereik van elementen in de List<T> opgegeven index en bevat het opgegeven aantal elementen.

FindIndex(Predicate<T>)

Zoekt naar een element dat overeenkomt met de voorwaarden die zijn gedefinieerd door het opgegeven predicaat en retourneert de op nul gebaseerde index van het eerste exemplaar binnen het hele List<T>exemplaar.

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

Parameters

match: Predicate<T>

De Predicate<T> gemachtigde die de voorwaarden definieert van het element waarnaar moet worden gezocht.

Retouren

Int32

De op nul gebaseerde index van het eerste exemplaar van een element dat overeenkomt met de voorwaarden die zijn gedefinieerd door match, indien gevonden; anders -1.

Uitzonderingen

ArgumentNullException

match is null.

Voorbeelden

In het volgende voorbeeld wordt een Employee klasse met twee velden gedefinieerd en NameId. Het definieert ook een EmployeeSearch klasse met één methode, StartsWithdie aangeeft of het Employee.Name veld begint met een opgegeven subtekenreeks die aan de EmployeeSearch klasseconstructor wordt geleverd. Noteer de handtekening van deze methode

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

komt overeen met de handtekening van de gemachtigde die kan worden doorgegeven aan de FindIndex methode. In het voorbeeld wordt een List<Employee> object geïnstitueert, een aantal Employee objecten aan het object toegevoegd en vervolgens twee keer de FindIndex(Int32, Int32, Predicate<T>) methode aangeroepen om de hele verzameling te doorzoeken, de eerste keer voor het eerste Employee object waarvan Name het veld begint met J en de tweede keer voor het eerste Employee object waarvan Name het veld begint met 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

Opmerkingen

De List<T> zoekopdracht wordt doorgestuurd vanaf het eerste element en eindigt op het laatste element.

Dit Predicate<T> is een gemachtigde voor een methode die retourneert true als het object dat eraan is doorgegeven, overeenkomt met de voorwaarden die zijn gedefinieerd in de gemachtigde. De elementen van de huidige List<T> worden afzonderlijk doorgegeven aan de Predicate<T> gemachtigde. De gedelegeerde heeft de handtekening:

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Met deze methode wordt een lineaire zoekopdracht uitgevoerd; daarom is deze methode een O(n)-bewerking, waarbij n is Count.

Zie ook

Van toepassing op

FindIndex(Int32, Predicate<T>)

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

Parameters

startIndex: Int32

De op nul gebaseerde startindex van de zoekopdracht.

match: Predicate<T>

De Predicate<T> gemachtigde die de voorwaarden definieert van het element waarnaar moet worden gezocht.

Retouren

Int32

De op nul gebaseerde index van het eerste exemplaar van een element dat overeenkomt met de voorwaarden die zijn gedefinieerd door match, indien gevonden; anders -1.

Uitzonderingen

ArgumentNullException

match is null.

ArgumentOutOfRangeException

startIndex valt buiten het bereik van geldige indexen voor de List<T>.

Voorbeelden

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

komt overeen met de handtekening van de gemachtigde die kan worden doorgegeven aan de FindIndex methode. In het voorbeeld wordt een List<Employee> object geïnstitueert, een aantal Employee objecten aan het object toegevoegd en vervolgens tweemaal de FindIndex(Int32, Int32, Predicate<T>) methode aangeroepen om de verzameling te doorzoeken vanaf het vijfde lid (dat wil zeggen het lid bij index 4). De eerste keer zoekt het naar het eerste Employee object waarvan Name het veld begint met 'J'; de tweede keer zoekt het naar het eerste Employee object waarvan Name het veld begint met '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

Opmerkingen

De List<T> zoekopdracht begint bij startIndex en eindigt op het laatste element.

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Met deze methode wordt een lineaire zoekopdracht uitgevoerd; daarom is deze methode een O(n)-bewerking, waarbij n het aantal elementen is van startIndex tot het einde van de List<T>.

Zie ook

Van toepassing op

FindIndex(Int32, Int32, Predicate<T>)

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

Parameters

startIndex: Int32

De op nul gebaseerde startindex van de zoekopdracht.

count: Int32

Het aantal elementen in de sectie dat moet worden gezocht.

match: Predicate<T>

De Predicate<T> gemachtigde die de voorwaarden definieert van het element waarnaar moet worden gezocht.

Retouren

Int32

De op nul gebaseerde index van het eerste exemplaar van een element dat overeenkomt met de voorwaarden die zijn gedefinieerd door match, indien gevonden; anders -1.

Uitzonderingen

ArgumentNullException

match is null.

ArgumentOutOfRangeException

startIndex valt buiten het bereik van geldige indexen voor de List<T>.

– of –

count is kleiner dan 0.

– of –

startIndex en count geef geen geldige sectie op in de List<T>.

Voorbeelden

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

komt overeen met de handtekening van de gemachtigde die kan worden doorgegeven aan de FindIndex methode. In het voorbeeld wordt een List<Employee> object geïnstitueert, een aantal Employee objecten aan het object toegevoegd en wordt de FindIndex(Int32, Int32, Predicate<T>) methode twee keer aangeroepen om de hele verzameling te doorzoeken (dat wil zeggen, de leden van index 0 naar index Count - 1). De eerste keer zoekt het naar het eerste Employee object waarvan Name het veld begint met 'J'; de tweede keer zoekt het naar het eerste Employee object waarvan Name het veld begint met '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

Opmerkingen

De List<T> zoekopdracht begint bij startIndex en eindigt op startIndex plus count min 1, als count deze groter is dan 0.

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Met deze methode wordt een lineaire zoekopdracht uitgevoerd; daarom is deze methode een O(n)-bewerking, waarbij n is count.

Zie ook

Van toepassing op

Feedback

Is deze pagina nuttig?