List<T>.FindIndex Methode

Referenz

Definition

Namespace:: System.Collections.Generic

Assembly:: System.Collections.dll

Assembly:: mscorlib.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 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>)

Quelle:: List.cs

Quelle:: List.cs

Quelle:: List.cs

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

ArgumentNullException

match ist null.

ArgumentOutOfRangeException

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 definiert: Name und Id. Außerdem wird eine EmployeeSearch Klasse mit einer einzelnen Methode definiert, die angibt, StartsWithob das Employee.Name Feld mit einer angegebenen Teilzeichenfolge beginnt, die für den 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 dann die FindIndex(Int32, Int32, Predicate<T>) -Methode zweimal auf, um die gesamte Auflistung (d. a. die Member von Index 0 bis Index Count - 1) zu durchsuchen. Beim ersten Mal sucht es nach dem ersten Employee Objekt, dessen Name Feld mit "J" beginnt. Beim zweiten 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> wird vorwärts gesucht, beginnend bei startIndex und endet bei startIndex plus count minus 1, wenn count größer als 0 ist.

ist Predicate<T> ein Delegat an eine Methode, die zurückgibt true , wenn das an sie übergebene Objekt den im Delegaten definierten Bedingungen entspricht. Die Elemente des aktuellen List<T> werden einzeln an den Predicate<T> Delegaten übergeben. Der Delegat verfügt über die Signatur:

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Diese Methode führt eine lineare Suche aus. Daher handelt es sich bei dieser Methode um einen O(n)-Vorgang, wobei n für steht count.

Weitere Informationen

Gilt für:

FindIndex(Predicate<T>)

Quelle:: List.cs

Quelle:: List.cs

Quelle:: List.cs

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

ArgumentNullException

match ist null.

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. Das Beispiel instanziiert ein List<Employee> -Objekt, fügt eine Reihe von Employee -Objekten hinzu und ruft dann die FindIndex(Int32, Int32, Predicate<T>) -Methode zweimal auf, um die gesamte Auflistung zu durchsuchen. Dies ist das erste Mal für das erste Employee Objekt, dessen Name Feld mit "J" beginnt, und das zweite Mal für das erste 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(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> wird nach vorne gesucht, beginnend beim ersten Element und endend beim letzten Element.

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Diese Methode führt eine lineare Suche aus. Daher handelt es sich bei dieser Methode um einen O(n)-Vorgang, wobei n für steht Count.

Weitere Informationen

Gilt für:

FindIndex(Int32, Predicate<T>)

Quelle:: List.cs

Quelle:: List.cs

Quelle:: List.cs

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

ArgumentNullException

match ist null.

ArgumentOutOfRangeException

startIndex liegt außerhalb des Bereichs der gültigen Indizes für das 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. Das Beispiel instanziiert ein List<Employee> -Objekt, fügt eine Reihe von Employee -Objekten hinzu und ruft dann die FindIndex(Int32, Int32, Predicate<T>) -Methode zweimal auf, um die Auflistung beginnend mit dem fünften Member (d. a. dem Member am Index 4) zu durchsuchen. Beim ersten Mal sucht es nach dem ersten Employee Objekt, dessen Name Feld mit "J" beginnt. Beim zweiten 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> wird nach vorne gesucht, beginnend am startIndex letzten Element und endend.

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Diese Methode führt eine lineare Suche aus. Daher handelt es sich bei dieser Methode um einen O(n)-Vorgang, wobei n die Anzahl der Elemente von bis startIndex zum Ende des List<T>ist.

Weitere Informationen

Gilt für:

Freigeben über

List<T>.FindIndex Methode

Definition

Überlädt

FindIndex(Int32, Int32, Predicate<T>)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

FindIndex(Predicate<T>)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

FindIndex(Int32, Predicate<T>)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

Zusätzliche Ressourcen