List<T>.FindIndex Metod

Definition

Namnområde:: System.Collections.Generic

Sammansättningar:: mscorlib.dll, System.Collections.dll

Sammansättning:: mscorlib.dll

Sammansättning:: System.Collections.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Söker efter ett element som matchar de villkor som definierats av ett angivet predikat och returnerar det nollbaserade indexet för den första förekomsten inom List<T> eller en del av den. Den här metoden returnerar -1 om ett objekt som matchar villkoren inte hittas.

Överlagringar

Name	Description
FindIndex(Predicate<T>)	Söker efter ett element som matchar de villkor som definierats av det angivna predikatet och returnerar det nollbaserade indexet för den första förekomsten i hela List<T>.
FindIndex(Int32, Predicate<T>)	Söker efter ett element som matchar de villkor som definierats av det angivna predikatet och returnerar det nollbaserade indexet för den första förekomsten inom elementintervallet List<T> i som sträcker sig från det angivna indexet till det sista elementet.
FindIndex(Int32, Int32, Predicate<T>)	Söker efter ett element som matchar de villkor som definierats av det angivna predikatet och returnerar det nollbaserade indexet för den första förekomsten inom elementintervallet List<T> i som börjar vid det angivna indexet och innehåller det angivna antalet element.

FindIndex(Predicate<T>)

Söker efter ett element som matchar de villkor som definierats av det angivna predikatet och returnerar det nollbaserade indexet för den första förekomsten i hela 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

Parametrar

match: Predicate<T>

Ombudet Predicate<T> som definierar villkoren för elementet som ska sökas efter.

Returer

Int32

Det nollbaserade indexet för den första förekomsten av ett element som matchar de villkor som definieras av match, om det hittas, annars -1.

Undantag

ArgumentNullException

match är null.

Exempel

I följande exempel definieras en Employee klass med två fält och NameId. Den definierar också en EmployeeSearch klass med en enda metod, StartsWith, som anger om Employee.Name fältet börjar med en angiven delsträng som levereras till EmployeeSearch klasskonstruktorn. Observera signaturen för den här metoden

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

motsvarar signaturen för ombudet som kan skickas till FindIndex metoden. Exemplet instansierar ett List<Employee> objekt, lägger till ett antal Employee objekt till det och anropar FindIndex(Int32, Int32, Predicate<T>) sedan metoden två gånger för att söka i hela samlingen, första gången för det första Employee objektet vars Name fält börjar med "J" och andra gången för det första Employee objektet vars Name fält börjar med "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

Kommentarer

List<T> Söks framåt med början vid det första elementet och slutar vid det sista elementet.

Predicate<T> är ett ombud till en metod som returnerar true om objektet som skickas till det matchar de villkor som definierats i ombudet. Elementen i den aktuella List<T> skickas individuellt till ombudet Predicate<T> . Ombudet har signaturen:

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Den här metoden utför en linjär sökning. Därför är den här metoden en O(n) åtgärd, där n är Count.

Se även

Gäller för

FindIndex(Int32, Predicate<T>)

Söker efter ett element som matchar de villkor som definierats av det angivna predikatet och returnerar det nollbaserade indexet för den första förekomsten inom elementintervallet List<T> i som sträcker sig från det angivna indexet till det sista elementet.

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

Parametrar

startIndex: Int32

Det nollbaserade startindexet för sökningen.

match: Predicate<T>

Ombudet Predicate<T> som definierar villkoren för elementet som ska sökas efter.

Returer

Int32

Det nollbaserade indexet för den första förekomsten av ett element som matchar de villkor som definieras av match, om det hittas, annars -1.

Undantag

ArgumentNullException

match är null.

ArgumentOutOfRangeException

startIndex ligger utanför intervallet för giltiga index för List<T>.

Exempel

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

motsvarar signaturen för ombudet som kan skickas till FindIndex metoden. Exemplet instansierar ett List<Employee> objekt, lägger till ett antal Employee objekt i det och anropar FindIndex(Int32, Int32, Predicate<T>) sedan metoden två gånger för att söka i samlingen från och med dess femte medlem (det vill säga medlemmen vid index 4). Första gången söker den efter det första Employee objektet vars Name fält börjar med "J". Den andra gången söker det efter det första Employee objektet vars Name fält börjar med "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

Kommentarer

List<T> Söks framåt med början vid startIndex och slutar vid det sista elementet.

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Den här metoden utför en linjär sökning. Därför är den här metoden en O(n) åtgärd, där n är antalet element från startIndex till slutet av List<T>.

Se även

Gäller för

FindIndex(Int32, Int32, Predicate<T>)

Söker efter ett element som matchar de villkor som definierats av det angivna predikatet och returnerar det nollbaserade indexet för den första förekomsten inom elementintervallet List<T> i som börjar vid det angivna indexet och innehåller det angivna antalet element.

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

Parametrar

startIndex: Int32

Det nollbaserade startindexet för sökningen.

count: Int32

Antalet element i avsnittet som ska sökas.

match: Predicate<T>

Ombudet Predicate<T> som definierar villkoren för elementet som ska sökas efter.

Returer

Int32

Det nollbaserade indexet för den första förekomsten av ett element som matchar de villkor som definieras av match, om det hittas, annars -1.

Undantag

ArgumentNullException

match är null.

ArgumentOutOfRangeException

startIndex ligger utanför intervallet för giltiga index för List<T>.

-eller-

count är mindre än 0.

-eller-

startIndex och count ange inte ett giltigt avsnitt i List<T>.

Exempel

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

motsvarar signaturen för ombudet som kan skickas till FindIndex metoden. Exemplet instansierar ett List<Employee> objekt, lägger till ett antal Employee objekt till det och anropar FindIndex(Int32, Int32, Predicate<T>) sedan metoden två gånger för att söka i hela samlingen (det vill säga medlemmarna från index 0 till index Count - 1). Första gången söker den efter det första Employee objektet vars Name fält börjar med "J". Den andra gången söker det efter det första Employee objektet vars Name fält börjar med "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

Kommentarer

List<T> Söks framåt med början vid startIndex och slutar på startIndex plus count minus 1, om count är större än 0.

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Den här metoden utför en linjär sökning. Därför är den här metoden en O(n) åtgärd, där n är count.

Se även

Gäller för

Feedback

Var den här sidan till hjälp?