List<T>.FindIndex Methode

Definition

Sucht nach einem Element, das die durch ein angegebenes Prädikat definierten Bedingungen erfüllt, und gibt den nullbasierten Index des ersten Vorkommens in der List<T> oder einem Teil davon zurück. Diese Methode gibt -1 zurück, wenn kein Element gefunden wird, das den Bedingungen entspricht.

Überlädt

FindIndex(Int32, Int32, Predicate<T>)

Sucht nach einem Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, und gibt den nullbasierten Index des ersten Vorkommens innerhalb des Bereichs von Elementen im List<T> zurück, der am angegebenen Index beginnt und die angegebene Anzahl von Elementen umfasst.

FindIndex(Predicate<T>)

Sucht nach einem Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, und gibt den nullbasierten Index des ersten Vorkommens im gesamten List<T> zurück.

FindIndex(Int32, Predicate<T>)

Sucht nach einem Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, und gibt den nullbasierten Index des ersten Vorkommens innerhalb des Bereichs von Elementen im List<T> zurück, der vom angegebenen Index bis zum letzten Element reicht.

FindIndex(Int32, Int32, Predicate<T>)

Sucht nach einem Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, und gibt den nullbasierten Index des ersten Vorkommens innerhalb des Bereichs von Elementen im List<T> zurück, der am angegebenen Index beginnt und die angegebene Anzahl von Elementen umfasst.

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

Parameter

startIndex
Int32

Der nullbasierte Startindex für die Suche.

count
Int32

Die Anzahl der Elemente im zu durchsuchenden Abschnitt.

match
Predicate<T>

Der Predicate<T>-Delegat, der die Bedingungen für das Element definiert, nach dem gesucht werden soll.

Gibt zurück

Int32

Der nullbasierte Index des ersten Vorkommens eines Elements, das mit den durch match definierten Bedingungen übereinstimmt, sofern gefunden; andernfalls -1.

Ausnahmen

match ist null.

startIndex liegt außerhalb des Bereichs der gültigen Indizes für das List<T>.

- oder - count ist kleiner als 0.

- oder - startIndex und count geben keinen gültigen Abschnitt in der List<T> an.

Beispiele

Im folgenden Beispiel wird eine Employee Klasse mit zwei Feldern Name und Id. Außerdem wird eine EmployeeSearch Klasse mit einer einzigen Methode definiert, die angibt, StartsWithob das Employee.Name Feld mit einer angegebenen Teilzeichenfolge beginnt, die dem EmployeeSearch Klassenkonstruktor bereitgestellt wird. Beachten Sie die Signatur dieser Methode

public bool StartsWith(Employee e)  
Public Function StartsWith(e As Employee) As Boolean  

entspricht der Signatur des Delegaten, der an die FindIndex Methode übergeben werden kann. Das Beispiel instanziiert ein List<Employee> Objekt, fügt eine Reihe von Employee Objekten hinzu, und ruft die FindIndex(Int32, Int32, Predicate<T>) Methode dann zweimal auf, um die gesamte Auflistung zu durchsuchen (also die Elemente von Index 0 bis Index Count - 1). Zum ersten Mal sucht es nach dem ersten Employee Objekt, dessen Name Feld mit "J" beginnt; das zweite Mal sucht es nach dem ersten Employee Objekt, dessen Name Feld mit "Ju" beginnt.

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

Hinweise

Die List<T> Suche beginnt mit startIndex plus 1 und endet mit startIndex plus count 1, wenn count größer als 0 ist.

Dies Predicate<T> ist eine Stellvertretung an eine Methode, die zurückgibt true , wenn das an sie übergebene Objekt mit den in der Stellvertretung definierten Bedingungen übereinstimmt. Die Elemente des Aktuellen List<T> werden einzeln an die Predicate<T> Stellvertretung übergeben. Die Stellvertretung hat die Signatur:

public bool methodName(T obj)  
Public Function methodName(obj As T) As Boolean  

Diese Methode führt eine lineare Suche aus; Daher ist diese Methode ein O(n)-Vorgang, wobei n ist count.

Siehe auch

Gilt für

FindIndex(Predicate<T>)

Sucht nach einem Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, und gibt den nullbasierten Index des ersten Vorkommens im gesamten List<T> zurück.

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

Parameter

match
Predicate<T>

Der Predicate<T>-Delegat, der die Bedingungen für das Element definiert, nach dem gesucht werden soll.

Gibt zurück

Int32

Der nullbasierte Index des ersten Vorkommens eines Elements, das mit den durch match definierten Bedingungen übereinstimmt, sofern gefunden; andernfalls -1.

Ausnahmen

match ist null.

Beispiele

Im folgenden Beispiel wird eine Employee Klasse mit zwei Feldern Name und Id. Außerdem wird eine EmployeeSearch Klasse mit einer einzigen Methode definiert, die angibt, StartsWithob das Employee.Name Feld mit einer angegebenen Teilzeichenfolge beginnt, die dem EmployeeSearch Klassenkonstruktor bereitgestellt wird. Beachten Sie die Signatur dieser Methode

public bool StartsWith(Employee e)  
Public Function StartsWith(e As Employee) As Boolean  

entspricht der Signatur des Delegaten, der an die FindIndex Methode übergeben werden kann. Das Beispiel instanziiert ein List<Employee> Objekt, fügt eine Reihe von Employee Objekten hinzu, und ruft die FindIndex(Int32, Int32, Predicate<T>) Methode dann zweimal auf, um die gesamte Auflistung zu durchsuchen, das erste Mal für das erste Employee Objekt, dessen Feld mit "J" beginnt, und das zweite Mal für das erste Employee Objekt, dessen Name Name Feld mit "Ju" beginnt.

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

Hinweise

Die List<T> suche nach vorne ab dem ersten Element und endet am letzten Element.

Dies Predicate<T> ist eine Stellvertretung an eine Methode, die zurückgibt true , wenn das an sie übergebene Objekt mit den in der Stellvertretung definierten Bedingungen übereinstimmt. Die Elemente des Aktuellen List<T> werden einzeln an die Predicate<T> Stellvertretung übergeben. Die Stellvertretung hat die Signatur:

public bool methodName(T obj)  
Public Function methodName(obj As T) As Boolean  

Diese Methode führt eine lineare Suche aus; Daher ist diese Methode ein O(n)-Vorgang, wobei n ist Count.

Siehe auch

Gilt für

FindIndex(Int32, Predicate<T>)

Sucht nach einem Element, das die durch das angegebene Prädikat definierten Bedingungen erfüllt, und gibt den nullbasierten Index des ersten Vorkommens innerhalb des Bereichs von Elementen im List<T> zurück, der vom angegebenen Index bis zum letzten Element reicht.

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

Parameter

startIndex
Int32

Der nullbasierte Startindex für die Suche.

match
Predicate<T>

Der Predicate<T>-Delegat, der die Bedingungen für das Element definiert, nach dem gesucht werden soll.

Gibt zurück

Int32

Der nullbasierte Index des ersten Vorkommens eines Elements, das mit den durch match definierten Bedingungen übereinstimmt, sofern gefunden; andernfalls -1.

Ausnahmen

match ist null.

startIndex liegt außerhalb des Bereichs der gültigen Indizes für das List<T>.

Beispiele

Im folgenden Beispiel wird eine Employee Klasse mit zwei Feldern Name und Id. Außerdem wird eine EmployeeSearch Klasse mit einer einzigen Methode definiert, die angibt, StartsWithob das Employee.Name Feld mit einer angegebenen Teilzeichenfolge beginnt, die dem EmployeeSearch Klassenkonstruktor bereitgestellt wird. Beachten Sie die Signatur dieser Methode

public bool StartsWith(Employee e)  
Public Function StartsWith(e As Employee) As Boolean  

entspricht der Signatur des Delegaten, der an die FindIndex Methode übergeben werden kann. Das Beispiel instanziiert ein List<Employee> Objekt, fügt ihm eine Reihe von Employee Objekten hinzu, und ruft die FindIndex(Int32, Int32, Predicate<T>) Methode dann zweimal auf, um die Auflistung ab dem fünften Element (also dem Element bei Index 4) zu durchsuchen. Zum ersten Mal sucht es nach dem ersten Employee Objekt, dessen Name Feld mit "J" beginnt; das zweite Mal sucht es nach dem ersten Employee Objekt, dessen Name Feld mit "Ju" beginnt.

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

Hinweise

Die List<T> suche nach vorne ab und startIndex endet am letzten Element.

Dies Predicate<T> ist eine Stellvertretung an eine Methode, die zurückgibt true , wenn das an sie übergebene Objekt mit den in der Stellvertretung definierten Bedingungen übereinstimmt. Die Elemente des Aktuellen List<T> werden einzeln an die Predicate<T> Stellvertretung übergeben. Die Stellvertretung hat die Signatur:

public bool methodName(T obj)  
Public Function methodName(obj As T) As Boolean  

Diese Methode führt eine lineare Suche aus; Daher ist diese Methode ein O(n)-Vorgang, wobei n die Anzahl der Elemente von startIndex bis zum Ende der List<T>.

Siehe auch

Gilt für