List<T>.FindIndex Methode

Definition

Namespace:: System.Collections.Generic

Assemblys:: mscorlib.dll, System.Collections.dll

Assembly:: mscorlib.dll

Assembly:: System.Collections.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Sucht nach einem Element, das den von einem angegebenen Prädikat definierten Bedingungen entspricht, und gibt den nullbasierten Index des ersten Vorkommens innerhalb List<T> oder eines Teils davon zurück. Diese Methode gibt -1 zurück, wenn ein Element, das den Bedingungen entspricht, nicht gefunden wird.

Überlädt

Name	Beschreibung
FindIndex(Predicate<T>)	Sucht nach einem Element, das den vom angegebenen Prädikat definierten Bedingungen entspricht, und gibt den nullbasierten Index des ersten Vorkommens innerhalb des gesamten List<T>Zurück.
FindIndex(Int32, Predicate<T>)	Sucht nach einem Element, das den vom angegebenen Prädikat definierten Bedingungen entspricht, und gibt den nullbasierten Index des ersten Vorkommens innerhalb des Elementbereichs zurück List<T> , der sich vom angegebenen Index bis zum letzten Element erstreckt.
FindIndex(Int32, Int32, Predicate<T>)	Sucht nach einem Element, das den vom angegebenen Prädikat definierten Bedingungen entspricht, und gibt den nullbasierten Index des ersten Vorkommens innerhalb des Elementbereichs zurück List<T> , der am angegebenen Index beginnt und die angegebene Anzahl von Elementen enthält.

FindIndex(Predicate<T>)

Sucht nach einem Element, das den vom angegebenen Prädikat definierten Bedingungen entspricht, und gibt den nullbasierten Index des ersten Vorkommens innerhalb des 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 Delegat Predicate<T> , der die Bedingungen des elements definiert, nach dem gesucht werden soll.

Gibt zurück

Int32

Der nullbasierte Index des ersten Vorkommens eines Elements, das den von match, falls gefundenen Bedingungen entspricht, andernfalls -1.

Ausnahmen

ArgumentNullException

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. Im Beispiel wird ein List<Employee> Objekt instanziiert, eine Reihe von Employee Objekten hinzugefügt, und anschließend wird die FindIndex(Int32, Int32, Predicate<T>) Methode zweimal aufgerufen, 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 NameName 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 erfolgt vorwärts beginnend mit dem ersten Element und endet am letzten Element.

Dies Predicate<T> ist ein Delegat an eine Methode, die zurückgibt true , wenn das an sie übergebene Objekt den in der Stellvertretung definierten Bedingungen entspricht. 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 durch; Daher ist diese Methode ein O(n)-Vorgang, wobei n ist Count.

Weitere Informationen

Gilt für:

FindIndex(Int32, Predicate<T>)

Sucht nach einem Element, das den vom angegebenen Prädikat definierten Bedingungen entspricht, und gibt den nullbasierten Index des ersten Vorkommens innerhalb des Elementbereichs zurück List<T> , der sich vom angegebenen Index bis zum letzten Element erstreckt.

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

match: Predicate<T>

Der Delegat Predicate<T> , der die Bedingungen des elements definiert, nach dem gesucht werden soll.

Gibt zurück

Int32

Der nullbasierte Index des ersten Vorkommens eines Elements, das den von match, falls gefundenen Bedingungen entspricht, andernfalls -1.

Ausnahmen

ArgumentNullException

match ist null.

ArgumentOutOfRangeException

startIndex liegt außerhalb des Bereichs gültiger Indizes für die List<T>.

Beispiele

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. Im Beispiel wird ein List<Employee> Objekt instanziiert, ihm eine Reihe von Employee Objekten hinzugefügt, und anschließend wird die FindIndex(Int32, Int32, Predicate<T>) Methode zweimal aufgerufen, um die Auflistung zu durchsuchen, beginnend mit dem fünften Element (d. a. dem Element bei Index 4). Beim ersten Mal wird nach dem ersten Employee Objekt gesucht, 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 beginnt mit startIndex dem letzten Element und endet mit dem letzten Element.

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

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

Weitere Informationen

Gilt für:

FindIndex(Int32, Int32, Predicate<T>)

Sucht nach einem Element, das den vom angegebenen Prädikat definierten Bedingungen entspricht, und gibt den nullbasierten Index des ersten Vorkommens innerhalb des Elementbereichs zurück List<T> , der am angegebenen Index beginnt und die angegebene Anzahl von Elementen enthält.

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

count: Int32

Die Anzahl der zu durchsuchenden Elemente im Abschnitt.

match: Predicate<T>

Der Delegat Predicate<T> , der die Bedingungen des elements definiert, nach dem gesucht werden soll.

Gibt zurück

Int32

Der nullbasierte Index des ersten Vorkommens eines Elements, das den von match, falls gefundenen Bedingungen entspricht, andernfalls -1.

Ausnahmen

ArgumentNullException

match ist null.

ArgumentOutOfRangeException

startIndex liegt außerhalb des Bereichs gültiger Indizes für die List<T>.

-oder-

count ist kleiner als 0.

-oder-

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

Beispiele

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. Im Beispiel wird ein List<Employee> Objekt instanziiert, eine Reihe von Employee Objekten hinzugefügt, und anschließend wird die FindIndex(Int32, Int32, Predicate<T>) Methode zweimal aufgerufen, um die gesamte Auflistung zu durchsuchen (d. r. die Elemente von Index 0 bis Index Count - 1). Beim ersten Mal wird nach dem ersten Employee Objekt gesucht, 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 ab und startIndex endet mit startIndex plus count minus 1, wenn count größer als 0 ist.

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

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

Weitere Informationen

Gilt für:

Feedback

War diese Seite hilfreich?