Array.LastIndexOf Methode

Definitie

Naamruimte:
System
Assembly's:
mscorlib.dll, System.Runtime.dll
Assembly's:
netstandard.dll, System.Runtime.dll
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Retourneert de index van het laatste exemplaar van een waarde in een eendimensionale Array waarde of in een deel van de Array.

Overloads

Name Description
LastIndexOf(Array, Object)

Zoekt naar het opgegeven object en retourneert de index van het laatste exemplaar binnen de gehele eendimensionale Array.
LastIndexOf(Array, Object, Int32)

Zoekt naar het opgegeven object en retourneert de index van het laatste exemplaar binnen het bereik van elementen in het eendimensionale Array element dat van het eerste element naar de opgegeven index uitbreidt.
LastIndexOf(Array, Object, Int32, Int32)

Zoekt naar het opgegeven object en retourneert de index van het laatste exemplaar binnen het bereik van elementen in het eendimensionale Array element dat het opgegeven aantal elementen bevat en eindigt bij de opgegeven index.
LastIndexOf<T>(T[], T)

Zoekt naar het opgegeven object en retourneert de index van het laatste exemplaar in het hele Arrayobject.
LastIndexOf<T>(T[], T, Int32)

Zoekt naar het opgegeven object en retourneert de index van het laatste exemplaar binnen het bereik van elementen in het Array opgegeven element van het eerste element naar de opgegeven index.
LastIndexOf<T>(T[], T, Int32, Int32)

Zoekt naar het opgegeven object en retourneert de index van het laatste exemplaar binnen het bereik van elementen in het Array opgegeven aantal elementen en eindigt op de opgegeven index.

LastIndexOf(Array, Object)

Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs

Zoekt naar het opgegeven object en retourneert de index van het laatste exemplaar binnen de gehele eendimensionale Array.

public:
 static int LastIndexOf(Array ^ array, System::Object ^ value);
public static int LastIndexOf(Array array, object value);
public static int LastIndexOf(Array array, object? value);
static member LastIndexOf : Array * obj -> int
Public Shared Function LastIndexOf (array As Array, value As Object) As Integer

Parameters

array
Array

De eendimensionale Array om te zoeken.

value
Object

Het object dat moet worden gevonden in array.

Retouren

Int32

De index van het laatste exemplaar van value binnen het gehele arrayexemplaar, indien gevonden; anders is de ondergrens van de matrix min 1.

Uitzonderingen

ArgumentNullException

array is null.

RankException

array is multidimensionaal.

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u de index kunt bepalen van het laatste exemplaar van een opgegeven element in een matrix.

let printIndexAndValues (arr: 'a []) =
   for i = arr.GetLowerBound 0 to arr.GetUpperBound 0 do
      printfn $"\t[{i}]:\t{arr[i]}"

// Creates and initializes a new Array with three elements of the same value.
let myArray = 
   [| "the"; "quick"; "brown"; "fox"
      "jumps"; "over"; "the"; "lazy"
      "dog"; "in"; "the"; "barn" |]

// Displays the values of the Array.
printfn "The Array contains the following values:"
printIndexAndValues myArray

// Searches for the last occurrence of the duplicated value.
let myString = "the"
let myIndex = Array.LastIndexOf(myArray, myString)
printfn $"The last occurrence of \"{myString}\" is at index {myIndex}."

// Searches for the last occurrence of the duplicated value in the first section of the Array.
let myIndex = Array.LastIndexOf(myArray, myString, 8)
printfn $"The last occurrence of \"{myString}\" between the start and index 8 is at index {myIndex}."

// Searches for the last occurrence of the duplicated value in a section of the Array.
// Note that the start index is greater than the end index because the search is done backward.
let myIndex = Array.LastIndexOf( myArray, myString, 10, 6 )
printfn $"The last occurrence of \"{myString}\" between index 5 and index 10 is at index {myIndex}."


//      This code produces the following output.
//
//      The Array contains the following values:
//         [0]:    the
//         [1]:    quick
//         [2]:    brown
//         [3]:    fox
//         [4]:    jumps
//         [5]:    over
//         [6]:    the
//         [7]:    lazy
//         [8]:    dog
//         [9]:    in
//         [10]:    the
//         [11]:    barn
//      The last occurrence of "the" is at index 10.
//      The last occurrence of "the" between the start and index 8 is at index 6.
//      The last occurrence of "the" between index 5 and index 10 is at index 10.

// Creates and initializes a new Array with three elements of the same value.
Array myArray=Array.CreateInstance( typeof(string), 12 );
myArray.SetValue( "the", 0 );
myArray.SetValue( "quick", 1 );
myArray.SetValue( "brown", 2 );
myArray.SetValue( "fox", 3 );
myArray.SetValue( "jumps", 4 );
myArray.SetValue( "over", 5 );
myArray.SetValue( "the", 6 );
myArray.SetValue( "lazy", 7 );
myArray.SetValue( "dog", 8 );
myArray.SetValue( "in", 9 );
myArray.SetValue( "the", 10 );
myArray.SetValue( "barn", 11 );

// Displays the values of the Array.
Console.WriteLine( "The Array contains the following values:" );
PrintIndexAndValues( myArray );

// Searches for the last occurrence of the duplicated value.
string myString = "the";
int myIndex = Array.LastIndexOf( myArray, myString );
Console.WriteLine( "The last occurrence of \"{0}\" is at index {1}.", myString, myIndex );

// Searches for the last occurrence of the duplicated value in the first section of the Array.
myIndex = Array.LastIndexOf( myArray, myString, 8 );
Console.WriteLine( "The last occurrence of \"{0}\" between the start and index 8 is at index {1}.", myString, myIndex );

// Searches for the last occurrence of the duplicated value in a section of the Array.
// Note that the start index is greater than the end index because the search is done backward.
myIndex = Array.LastIndexOf( myArray, myString, 10, 6 );
Console.WriteLine( "The last occurrence of \"{0}\" between index 5 and index 10 is at index {1}.", myString, myIndex );

void PrintIndexAndValues( Array anArray )  {
   for ( int i = anArray.GetLowerBound(0); i <= anArray.GetUpperBound(0); i++ )
      Console.WriteLine( "\t[{0}]:\t{1}", i, anArray.GetValue( i ) );
}

/*
This code produces the following output.

The Array contains the following values:
   [0]:    the
   [1]:    quick
   [2]:    brown
   [3]:    fox
   [4]:    jumps
   [5]:    over
   [6]:    the
   [7]:    lazy
   [8]:    dog
   [9]:    in
   [10]:    the
   [11]:    barn
The last occurrence of "the" is at index 10.
The last occurrence of "the" between the start and index 8 is at index 6.
The last occurrence of "the" between index 5 and index 10 is at index 10.
*/

Public Class SamplesArray    
    
    Public Shared Sub Main()
        
        ' Creates and initializes a new Array with three elements of
        ' the same value.
        Dim myArray As Array = Array.CreateInstance(GetType(String), 12)
        myArray.SetValue("the", 0)
        myArray.SetValue("quick", 1)
        myArray.SetValue("brown", 2)
        myArray.SetValue("fox", 3)
        myArray.SetValue("jumps", 4)
        myArray.SetValue("over", 5)
        myArray.SetValue("the", 6)
        myArray.SetValue("lazy", 7)
        myArray.SetValue("dog", 8)
        myArray.SetValue("in", 9)
        myArray.SetValue("the", 10)
        myArray.SetValue("barn", 11)
        
        ' Displays the values of the Array.
        Console.WriteLine("The Array contains the following values:")
        PrintIndexAndValues(myArray)
        
        ' Searches for the last occurrence of the duplicated value.
        Dim myString As String = "the"
        Dim myIndex As Integer = Array.LastIndexOf(myArray, myString)
        Console.WriteLine("The last occurrence of ""{0}"" is at index {1}.", _
           myString, myIndex)
        
        ' Searches for the last occurrence of the duplicated value in the first
        ' section of the Array.
        myIndex = Array.LastIndexOf(myArray, myString, 8)
        Console.WriteLine("The last occurrence of ""{0}"" between the start " _
           + "and index 8 is at index {1}.", myString, myIndex)
        
        ' Searches for the last occurrence of the duplicated value in a section
        ' of the Array.  Note that the start index is greater than the end
        ' index because the search is done backward.
        myIndex = Array.LastIndexOf(myArray, myString, 10, 6)
        Console.WriteLine("The last occurrence of ""{0}"" between index 5 " _
           + "and index 10 is at index {1}.", myString, myIndex)
    End Sub
    
    
    Public Shared Sub PrintIndexAndValues(myArray As Array)
        Dim i As Integer
        For i = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
            Console.WriteLine(ControlChars.Tab + "[{0}]:" + ControlChars.Tab _
               + "{1}", i, myArray.GetValue(i))
        Next i
    End Sub
End Class

' This code produces the following output.
' 
' The Array contains the following values:
'     [0]:    the
'     [1]:    quick
'     [2]:    brown
'     [3]:    fox
'     [4]:    jumps
'     [5]:    over
'     [6]:    the
'     [7]:    lazy
'     [8]:    dog
'     [9]:    in
'     [10]:    the
'     [11]:    barn
' The last occurrence of "the" is at index 10.
' The last occurrence of "the" between the start and index 8 is at index 6.
' The last occurrence of "the" between index 5 and index 10 is at index 10.

Opmerkingen

De eendimensionale wordt Array achterwaarts gezocht vanaf het laatste element en eindigt op het eerste element.

De elementen worden vergeleken met de opgegeven waarde met behulp van de Object.Equals methode. Als het elementtype een niet-intrinsisch (door de gebruiker gedefinieerd) type is, wordt de Equals implementatie van dat type gebruikt.

Omdat de meeste matrices een ondergrens van nul hebben, retourneert deze methode over het algemeen -1 wanneer value deze niet wordt gevonden. In het zeldzame geval dat de ondergrens van de matrix gelijk is aan Int32.MinValue en value niet wordt gevonden, retourneert Int32.MaxValuedeze methode , wat is System.Int32.MinValue - 1.

Deze methode is een O(n)-bewerking, waarbij n de Length van array.

Deze methode gebruikt de Equals en CompareTo methoden van de Array methode om te bepalen of de Object opgegeven door de value parameter bestaat.

CompareTo methoden van de item parameter voor de objecten in de verzameling.

Zie ook

Van toepassing op

LastIndexOf(Array, Object, Int32)

Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs

Zoekt naar het opgegeven object en retourneert de index van het laatste exemplaar binnen het bereik van elementen in het eendimensionale Array element dat van het eerste element naar de opgegeven index uitbreidt.

public:
 static int LastIndexOf(Array ^ array, System::Object ^ value, int startIndex);
public static int LastIndexOf(Array array, object value, int startIndex);
public static int LastIndexOf(Array array, object? value, int startIndex);
static member LastIndexOf : Array * obj * int -> int
Public Shared Function LastIndexOf (array As Array, value As Object, startIndex As Integer) As Integer

Parameters

array
Array

De eendimensionale Array om te zoeken.

value
Object

Het object dat moet worden gevonden in array.

startIndex
Int32

De beginindex van de achterwaartse zoekopdracht.

Retouren

Int32

De index van het laatste exemplaar van value binnen het bereik van elementen in array die zich uitbreidt van het eerste element naar startIndex, indien gevonden; anders is de ondergrens van de matrix min 1.

Uitzonderingen

ArgumentNullException

array is null.

ArgumentOutOfRangeException

startIndex valt buiten het bereik van geldige indexen voor array.

RankException

array is multidimensionaal.

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u de index kunt bepalen van het laatste exemplaar van een opgegeven element in een matrix.

let printIndexAndValues (arr: 'a []) =
   for i = arr.GetLowerBound 0 to arr.GetUpperBound 0 do
      printfn $"\t[{i}]:\t{arr[i]}"

// Creates and initializes a new Array with three elements of the same value.
let myArray = 
   [| "the"; "quick"; "brown"; "fox"
      "jumps"; "over"; "the"; "lazy"
      "dog"; "in"; "the"; "barn" |]

// Displays the values of the Array.
printfn "The Array contains the following values:"
printIndexAndValues myArray

// Searches for the last occurrence of the duplicated value.
let myString = "the"
let myIndex = Array.LastIndexOf(myArray, myString)
printfn $"The last occurrence of \"{myString}\" is at index {myIndex}."

// Searches for the last occurrence of the duplicated value in the first section of the Array.
let myIndex = Array.LastIndexOf(myArray, myString, 8)
printfn $"The last occurrence of \"{myString}\" between the start and index 8 is at index {myIndex}."

// Searches for the last occurrence of the duplicated value in a section of the Array.
// Note that the start index is greater than the end index because the search is done backward.
let myIndex = Array.LastIndexOf( myArray, myString, 10, 6 )
printfn $"The last occurrence of \"{myString}\" between index 5 and index 10 is at index {myIndex}."


//      This code produces the following output.
//
//      The Array contains the following values:
//         [0]:    the
//         [1]:    quick
//         [2]:    brown
//         [3]:    fox
//         [4]:    jumps
//         [5]:    over
//         [6]:    the
//         [7]:    lazy
//         [8]:    dog
//         [9]:    in
//         [10]:    the
//         [11]:    barn
//      The last occurrence of "the" is at index 10.
//      The last occurrence of "the" between the start and index 8 is at index 6.
//      The last occurrence of "the" between index 5 and index 10 is at index 10.

// Creates and initializes a new Array with three elements of the same value.
Array myArray=Array.CreateInstance( typeof(string), 12 );
myArray.SetValue( "the", 0 );
myArray.SetValue( "quick", 1 );
myArray.SetValue( "brown", 2 );
myArray.SetValue( "fox", 3 );
myArray.SetValue( "jumps", 4 );
myArray.SetValue( "over", 5 );
myArray.SetValue( "the", 6 );
myArray.SetValue( "lazy", 7 );
myArray.SetValue( "dog", 8 );
myArray.SetValue( "in", 9 );
myArray.SetValue( "the", 10 );
myArray.SetValue( "barn", 11 );

// Displays the values of the Array.
Console.WriteLine( "The Array contains the following values:" );
PrintIndexAndValues( myArray );

// Searches for the last occurrence of the duplicated value.
string myString = "the";
int myIndex = Array.LastIndexOf( myArray, myString );
Console.WriteLine( "The last occurrence of \"{0}\" is at index {1}.", myString, myIndex );

// Searches for the last occurrence of the duplicated value in the first section of the Array.
myIndex = Array.LastIndexOf( myArray, myString, 8 );
Console.WriteLine( "The last occurrence of \"{0}\" between the start and index 8 is at index {1}.", myString, myIndex );

// Searches for the last occurrence of the duplicated value in a section of the Array.
// Note that the start index is greater than the end index because the search is done backward.
myIndex = Array.LastIndexOf( myArray, myString, 10, 6 );
Console.WriteLine( "The last occurrence of \"{0}\" between index 5 and index 10 is at index {1}.", myString, myIndex );

void PrintIndexAndValues( Array anArray )  {
   for ( int i = anArray.GetLowerBound(0); i <= anArray.GetUpperBound(0); i++ )
      Console.WriteLine( "\t[{0}]:\t{1}", i, anArray.GetValue( i ) );
}

/*
This code produces the following output.

The Array contains the following values:
   [0]:    the
   [1]:    quick
   [2]:    brown
   [3]:    fox
   [4]:    jumps
   [5]:    over
   [6]:    the
   [7]:    lazy
   [8]:    dog
   [9]:    in
   [10]:    the
   [11]:    barn
The last occurrence of "the" is at index 10.
The last occurrence of "the" between the start and index 8 is at index 6.
The last occurrence of "the" between index 5 and index 10 is at index 10.
*/

Public Class SamplesArray    
    
    Public Shared Sub Main()
        
        ' Creates and initializes a new Array with three elements of
        ' the same value.
        Dim myArray As Array = Array.CreateInstance(GetType(String), 12)
        myArray.SetValue("the", 0)
        myArray.SetValue("quick", 1)
        myArray.SetValue("brown", 2)
        myArray.SetValue("fox", 3)
        myArray.SetValue("jumps", 4)
        myArray.SetValue("over", 5)
        myArray.SetValue("the", 6)
        myArray.SetValue("lazy", 7)
        myArray.SetValue("dog", 8)
        myArray.SetValue("in", 9)
        myArray.SetValue("the", 10)
        myArray.SetValue("barn", 11)
        
        ' Displays the values of the Array.
        Console.WriteLine("The Array contains the following values:")
        PrintIndexAndValues(myArray)
        
        ' Searches for the last occurrence of the duplicated value.
        Dim myString As String = "the"
        Dim myIndex As Integer = Array.LastIndexOf(myArray, myString)
        Console.WriteLine("The last occurrence of ""{0}"" is at index {1}.", _
           myString, myIndex)
        
        ' Searches for the last occurrence of the duplicated value in the first
        ' section of the Array.
        myIndex = Array.LastIndexOf(myArray, myString, 8)
        Console.WriteLine("The last occurrence of ""{0}"" between the start " _
           + "and index 8 is at index {1}.", myString, myIndex)
        
        ' Searches for the last occurrence of the duplicated value in a section
        ' of the Array.  Note that the start index is greater than the end
        ' index because the search is done backward.
        myIndex = Array.LastIndexOf(myArray, myString, 10, 6)
        Console.WriteLine("The last occurrence of ""{0}"" between index 5 " _
           + "and index 10 is at index {1}.", myString, myIndex)
    End Sub
    
    
    Public Shared Sub PrintIndexAndValues(myArray As Array)
        Dim i As Integer
        For i = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
            Console.WriteLine(ControlChars.Tab + "[{0}]:" + ControlChars.Tab _
               + "{1}", i, myArray.GetValue(i))
        Next i
    End Sub
End Class

' This code produces the following output.
' 
' The Array contains the following values:
'     [0]:    the
'     [1]:    quick
'     [2]:    brown
'     [3]:    fox
'     [4]:    jumps
'     [5]:    over
'     [6]:    the
'     [7]:    lazy
'     [8]:    dog
'     [9]:    in
'     [10]:    the
'     [11]:    barn
' The last occurrence of "the" is at index 10.
' The last occurrence of "the" between the start and index 8 is at index 6.
' The last occurrence of "the" between index 5 and index 10 is at index 10.

Opmerkingen

De eendimensionale wordt Array achterwaarts gezocht vanaf startIndex en eindigend op het eerste element.

De elementen worden vergeleken met de opgegeven waarde met behulp van de Object.Equals methode. Als het elementtype een niet-intrinsisch (door de gebruiker gedefinieerd) type is, wordt de Equals implementatie van dat type gebruikt.

Omdat de meeste matrices een ondergrens van nul hebben, retourneert deze methode over het algemeen -1 wanneer value deze niet wordt gevonden. In het zeldzame geval dat de ondergrens van de matrix gelijk is aan Int32.MinValue en value niet wordt gevonden, retourneert Int32.MaxValuedeze methode , wat is System.Int32.MinValue - 1.

Deze methode is een O(n)-bewerking, waarbij n het aantal elementen van begin array tot startIndexen met .

Deze methode gebruikt de Equals en CompareTo methoden van de Array methode om te bepalen of de Object opgegeven door de value parameter bestaat.

Zie ook

Van toepassing op

LastIndexOf(Array, Object, Int32, Int32)

Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs

Zoekt naar het opgegeven object en retourneert de index van het laatste exemplaar binnen het bereik van elementen in het eendimensionale Array element dat het opgegeven aantal elementen bevat en eindigt bij de opgegeven index.

public:
 static int LastIndexOf(Array ^ array, System::Object ^ value, int startIndex, int count);
public static int LastIndexOf(Array array, object value, int startIndex, int count);
public static int LastIndexOf(Array array, object? value, int startIndex, int count);
static member LastIndexOf : Array * obj * int * int -> int
Public Shared Function LastIndexOf (array As Array, value As Object, startIndex As Integer, count As Integer) As Integer

Parameters

array
Array

De eendimensionale Array om te zoeken.

value
Object

Het object dat moet worden gevonden in array.

startIndex
Int32

De beginindex van de achterwaartse zoekopdracht.

count
Int32

Het aantal elementen in de sectie dat moet worden gezocht.

Retouren

Int32

De index van het laatste exemplaar binnen value het bereik van elementen in array dat het aantal elementen bevat dat is opgegeven en count eindigt op startIndex, indien gevonden; anders is de ondergrens van de matrix min 1.

Uitzonderingen

ArgumentNullException

array is null.

ArgumentOutOfRangeException

startIndex valt buiten het bereik van geldige indexen voor array.

– of –

count is kleiner dan nul.

– of –

startIndex en count geef geen geldige sectie op in array.

RankException

array is multidimensionaal.

Voorbeelden

In het volgende codevoorbeeld ziet u hoe u de index kunt bepalen van het laatste exemplaar van een opgegeven element in een matrix. Houd er rekening mee dat de LastIndexOf methode een achterwaartse zoekopdracht is; daarom count moet kleiner dan of gelijk zijn aan (startIndex min de ondergrens van de matrix plus 1).

let printIndexAndValues (arr: 'a []) =
   for i = arr.GetLowerBound 0 to arr.GetUpperBound 0 do
      printfn $"\t[{i}]:\t{arr[i]}"

// Creates and initializes a new Array with three elements of the same value.
let myArray = 
   [| "the"; "quick"; "brown"; "fox"
      "jumps"; "over"; "the"; "lazy"
      "dog"; "in"; "the"; "barn" |]

// Displays the values of the Array.
printfn "The Array contains the following values:"
printIndexAndValues myArray

// Searches for the last occurrence of the duplicated value.
let myString = "the"
let myIndex = Array.LastIndexOf(myArray, myString)
printfn $"The last occurrence of \"{myString}\" is at index {myIndex}."

// Searches for the last occurrence of the duplicated value in the first section of the Array.
let myIndex = Array.LastIndexOf(myArray, myString, 8)
printfn $"The last occurrence of \"{myString}\" between the start and index 8 is at index {myIndex}."

// Searches for the last occurrence of the duplicated value in a section of the Array.
// Note that the start index is greater than the end index because the search is done backward.
let myIndex = Array.LastIndexOf( myArray, myString, 10, 6 )
printfn $"The last occurrence of \"{myString}\" between index 5 and index 10 is at index {myIndex}."


//      This code produces the following output.
//
//      The Array contains the following values:
//         [0]:    the
//         [1]:    quick
//         [2]:    brown
//         [3]:    fox
//         [4]:    jumps
//         [5]:    over
//         [6]:    the
//         [7]:    lazy
//         [8]:    dog
//         [9]:    in
//         [10]:    the
//         [11]:    barn
//      The last occurrence of "the" is at index 10.
//      The last occurrence of "the" between the start and index 8 is at index 6.
//      The last occurrence of "the" between index 5 and index 10 is at index 10.

// Creates and initializes a new Array with three elements of the same value.
Array myArray=Array.CreateInstance( typeof(string), 12 );
myArray.SetValue( "the", 0 );
myArray.SetValue( "quick", 1 );
myArray.SetValue( "brown", 2 );
myArray.SetValue( "fox", 3 );
myArray.SetValue( "jumps", 4 );
myArray.SetValue( "over", 5 );
myArray.SetValue( "the", 6 );
myArray.SetValue( "lazy", 7 );
myArray.SetValue( "dog", 8 );
myArray.SetValue( "in", 9 );
myArray.SetValue( "the", 10 );
myArray.SetValue( "barn", 11 );

// Displays the values of the Array.
Console.WriteLine( "The Array contains the following values:" );
PrintIndexAndValues( myArray );

// Searches for the last occurrence of the duplicated value.
string myString = "the";
int myIndex = Array.LastIndexOf( myArray, myString );
Console.WriteLine( "The last occurrence of \"{0}\" is at index {1}.", myString, myIndex );

// Searches for the last occurrence of the duplicated value in the first section of the Array.
myIndex = Array.LastIndexOf( myArray, myString, 8 );
Console.WriteLine( "The last occurrence of \"{0}\" between the start and index 8 is at index {1}.", myString, myIndex );

// Searches for the last occurrence of the duplicated value in a section of the Array.
// Note that the start index is greater than the end index because the search is done backward.
myIndex = Array.LastIndexOf( myArray, myString, 10, 6 );
Console.WriteLine( "The last occurrence of \"{0}\" between index 5 and index 10 is at index {1}.", myString, myIndex );

void PrintIndexAndValues( Array anArray )  {
   for ( int i = anArray.GetLowerBound(0); i <= anArray.GetUpperBound(0); i++ )
      Console.WriteLine( "\t[{0}]:\t{1}", i, anArray.GetValue( i ) );
}

/*
This code produces the following output.

The Array contains the following values:
   [0]:    the
   [1]:    quick
   [2]:    brown
   [3]:    fox
   [4]:    jumps
   [5]:    over
   [6]:    the
   [7]:    lazy
   [8]:    dog
   [9]:    in
   [10]:    the
   [11]:    barn
The last occurrence of "the" is at index 10.
The last occurrence of "the" between the start and index 8 is at index 6.
The last occurrence of "the" between index 5 and index 10 is at index 10.
*/

Public Class SamplesArray    
    
    Public Shared Sub Main()
        
        ' Creates and initializes a new Array with three elements of
        ' the same value.
        Dim myArray As Array = Array.CreateInstance(GetType(String), 12)
        myArray.SetValue("the", 0)
        myArray.SetValue("quick", 1)
        myArray.SetValue("brown", 2)
        myArray.SetValue("fox", 3)
        myArray.SetValue("jumps", 4)
        myArray.SetValue("over", 5)
        myArray.SetValue("the", 6)
        myArray.SetValue("lazy", 7)
        myArray.SetValue("dog", 8)
        myArray.SetValue("in", 9)
        myArray.SetValue("the", 10)
        myArray.SetValue("barn", 11)
        
        ' Displays the values of the Array.
        Console.WriteLine("The Array contains the following values:")
        PrintIndexAndValues(myArray)
        
        ' Searches for the last occurrence of the duplicated value.
        Dim myString As String = "the"
        Dim myIndex As Integer = Array.LastIndexOf(myArray, myString)
        Console.WriteLine("The last occurrence of ""{0}"" is at index {1}.", _
           myString, myIndex)
        
        ' Searches for the last occurrence of the duplicated value in the first
        ' section of the Array.
        myIndex = Array.LastIndexOf(myArray, myString, 8)
        Console.WriteLine("The last occurrence of ""{0}"" between the start " _
           + "and index 8 is at index {1}.", myString, myIndex)
        
        ' Searches for the last occurrence of the duplicated value in a section
        ' of the Array.  Note that the start index is greater than the end
        ' index because the search is done backward.
        myIndex = Array.LastIndexOf(myArray, myString, 10, 6)
        Console.WriteLine("The last occurrence of ""{0}"" between index 5 " _
           + "and index 10 is at index {1}.", myString, myIndex)
    End Sub
    
    
    Public Shared Sub PrintIndexAndValues(myArray As Array)
        Dim i As Integer
        For i = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
            Console.WriteLine(ControlChars.Tab + "[{0}]:" + ControlChars.Tab _
               + "{1}", i, myArray.GetValue(i))
        Next i
    End Sub
End Class

' This code produces the following output.
' 
' The Array contains the following values:
'     [0]:    the
'     [1]:    quick
'     [2]:    brown
'     [3]:    fox
'     [4]:    jumps
'     [5]:    over
'     [6]:    the
'     [7]:    lazy
'     [8]:    dog
'     [9]:    in
'     [10]:    the
'     [11]:    barn
' The last occurrence of "the" is at index 10.
' The last occurrence of "the" between the start and index 8 is at index 6.
' The last occurrence of "the" between index 5 and index 10 is at index 10.

Opmerkingen

De eendimensionale waarde Array wordt achterwaarts gezocht vanaf startIndex en eindigend op startIndex min count plus 1, als count deze groter is dan 0.

De elementen worden vergeleken met de opgegeven waarde met behulp van de Object.Equals methode. Als het elementtype een niet-intrinsisch (door de gebruiker gedefinieerd) type is, wordt deEquals implementatie van dat type gebruikt.

Omdat de meeste matrices een ondergrens van nul hebben, retourneert deze methode over het algemeen -1 wanneer value deze niet wordt gevonden. In het zeldzame geval dat de ondergrens van de matrix gelijk is aan Int32.MinValue en value niet wordt gevonden, retourneert Int32.MaxValuedeze methode , wat is System.Int32.MinValue - 1.

Deze methode is een O(n)-bewerking, waarbij n .count

Deze methode gebruikt de Equals en CompareTo methoden van de Array methode om te bepalen of de Object opgegeven door de value parameter bestaat.

Zie ook

Van toepassing op

LastIndexOf<T>(T[], T)

Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs

Zoekt naar het opgegeven object en retourneert de index van het laatste exemplaar in het hele Arrayobject.

public:
generic <typename T>
 static int LastIndexOf(cli::array <T> ^ array, T value);
public static int LastIndexOf<T>(T[] array, T value);
static member LastIndexOf : 'T[] * 'T -> int
Public Shared Function LastIndexOf(Of T) (array As T(), value As T) As Integer

Type parameters

T

Het type van de elementen van de matrix.

Parameters

array
T[]

De eendimensionale, op nul gebaseerde Array zoekopdrachten.

value
T

Het object dat moet worden gevonden in array.

Retouren

Int32

De op nul gebaseerde index van het laatste exemplaar van value binnen het hele arrayexemplaar, indien gevonden; anders -1.

Uitzonderingen

ArgumentNullException

array is null.

Voorbeelden

In het volgende codevoorbeeld ziet u alle drie algemene overbelastingen van de LastIndexOf methode. Er wordt een matrix met tekenreeksen gemaakt, met één vermelding die tweemaal wordt weergegeven, op indexlocatie 0 en indexlocatie 5. De LastIndexOf<T>(T[], T) overbelasting van de methode doorzoekt de hele matrix vanaf het einde en zoekt het tweede exemplaar van de tekenreeks. De LastIndexOf<T>(T[], T, Int32) overbelasting van de methode wordt gebruikt om de matrix achterwaarts te doorzoeken vanaf indexlocatie 3 en door te gaan naar het begin van de matrix en het eerste exemplaar van de tekenreeks te vinden. Ten slotte wordt de overbelasting van de LastIndexOf<T>(T[], T, Int32, Int32) methode gebruikt om een bereik van vier vermeldingen te doorzoeken, te beginnen bij indexlocatie 4 en achteruit uit te breiden (dat wil gezegd, het doorzoekt de items op locaties 4, 3, 2 en 1); deze zoekopdracht retourneert -1 omdat er geen exemplaren van de zoekreeks in dat bereik zijn.

string[] dinosaurs = { "Tyrannosaurus",
    "Amargasaurus",
    "Mamenchisaurus",
    "Brachiosaurus",
    "Deinonychus",
    "Tyrannosaurus",
    "Compsognathus" };

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

Console.WriteLine(
    "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\"): {0}",
    Array.LastIndexOf(dinosaurs, "Tyrannosaurus"));

Console.WriteLine(
    "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\", 3): {0}",
    Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3));

Console.WriteLine(
    "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\", 4, 4): {0}",
    Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4));

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.LastIndexOf(dinosaurs, "Tyrannosaurus"): 5

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3): 0

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4): -1
*/

open System

let dinosaurs = 
    [| "Tyrannosaurus"
       "Amargasaurus"
       "Mamenchisaurus"
       "Brachiosaurus"
       "Deinonychus"
       "Tyrannosaurus"
       "Compsognathus" |]

printfn ""
for dino in dinosaurs do
    printfn $"{dino}"

Array.LastIndexOf(dinosaurs, "Tyrannosaurus")
|> printfn "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\"): %i"

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3)
|> printfn "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\", 3): %i"

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4)
|> printfn "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\", 4, 4): %i"

// This code example produces the following output:
//    
//    Tyrannosaurus
//    Amargasaurus
//    Mamenchisaurus
//    Brachiosaurus
//    Deinonychus
//    Tyrannosaurus
//    Compsognathus
//    
//    Array.LastIndexOf(dinosaurs, "Tyrannosaurus"): 5
//
//    Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3): 0
//
//    Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4): -1

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { "Tyrannosaurus", _
            "Amargasaurus", _
            "Mamenchisaurus", _
            "Brachiosaurus", _
            "Deinonychus", _
            "Tyrannosaurus", _
            "Compsognathus" }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "Array.LastIndexOf(dinosaurs, ""Tyrannosaurus""): {0}", _
            Array.LastIndexOf(dinosaurs, "Tyrannosaurus"))

        Console.WriteLine(vbLf & _
            "Array.LastIndexOf(dinosaurs, ""Tyrannosaurus"", 3): {0}", _
            Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3))

        Console.WriteLine(vbLf & _
            "Array.LastIndexOf(dinosaurs, ""Tyrannosaurus"", 4, 4): {0}", _
            Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4))

    End Sub
End Class

' This code example produces the following output:
'
'Tyrannosaurus
'Amargasaurus
'Mamenchisaurus
'Brachiosaurus
'Deinonychus
'Tyrannosaurus
'Compsognathus
'
'Array.LastIndexOf(dinosaurs, "Tyrannosaurus"): 5
'
'Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3): 0
'
'Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4): -1

Opmerkingen

Het Array wordt achterwaarts gezocht vanaf het laatste element en eindigt op het eerste element.

De elementen worden vergeleken met de opgegeven waarde met behulp van de Object.Equals methode. Als het elementtype een niet-intrinsisch (door de gebruiker gedefinieerd) type is, wordt de Equals implementatie van dat type gebruikt.

Deze methode is een O(n)-bewerking, waarbij n de Length van array.

Zie ook

Van toepassing op

LastIndexOf<T>(T[], T, Int32)

Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs

Zoekt naar het opgegeven object en retourneert de index van het laatste exemplaar binnen het bereik van elementen in het Array opgegeven element van het eerste element naar de opgegeven index.

public:
generic <typename T>
 static int LastIndexOf(cli::array <T> ^ array, T value, int startIndex);
public static int LastIndexOf<T>(T[] array, T value, int startIndex);
static member LastIndexOf : 'T[] * 'T * int -> int
Public Shared Function LastIndexOf(Of T) (array As T(), value As T, startIndex As Integer) As Integer

Type parameters

T

Het type van de elementen van de matrix.

Parameters

array
T[]

De eendimensionale, op nul gebaseerde Array zoekopdrachten.

value
T

Het object dat moet worden gevonden in array.

startIndex
Int32

De op nul gebaseerde beginindex van de achterwaartse zoekopdracht.

Retouren

Int32

De op nul gebaseerde index van het laatste exemplaar van value binnen het bereik van elementen in array die zich uitbreidt van het eerste element naar startIndex, indien gevonden; anders -1.

Uitzonderingen

ArgumentNullException

array is null.

ArgumentOutOfRangeException

startIndex valt buiten het bereik van geldige indexen voor array.

Voorbeelden

In het volgende codevoorbeeld ziet u alle drie algemene overbelastingen van de LastIndexOf methode. Er wordt een matrix met tekenreeksen gemaakt, met één vermelding die tweemaal wordt weergegeven, op indexlocatie 0 en indexlocatie 5. De LastIndexOf<T>(T[], T) overbelasting van de methode doorzoekt de hele matrix vanaf het einde en zoekt het tweede exemplaar van de tekenreeks. De LastIndexOf<T>(T[], T, Int32) overbelasting van de methode wordt gebruikt om de matrix achterwaarts te doorzoeken vanaf indexlocatie 3 en door te gaan naar het begin van de matrix en het eerste exemplaar van de tekenreeks te vinden. Ten slotte wordt de overbelasting van de LastIndexOf<T>(T[], T, Int32, Int32) methode gebruikt om een bereik van vier vermeldingen te doorzoeken, te beginnen bij indexlocatie 4 en achteruit uit te breiden (dat wil gezegd, het doorzoekt de items op locaties 4, 3, 2 en 1); deze zoekopdracht retourneert -1 omdat er geen exemplaren van de zoekreeks in dat bereik zijn.

string[] dinosaurs = { "Tyrannosaurus",
    "Amargasaurus",
    "Mamenchisaurus",
    "Brachiosaurus",
    "Deinonychus",
    "Tyrannosaurus",
    "Compsognathus" };

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

Console.WriteLine(
    "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\"): {0}",
    Array.LastIndexOf(dinosaurs, "Tyrannosaurus"));

Console.WriteLine(
    "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\", 3): {0}",
    Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3));

Console.WriteLine(
    "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\", 4, 4): {0}",
    Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4));

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.LastIndexOf(dinosaurs, "Tyrannosaurus"): 5

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3): 0

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4): -1
*/

open System

let dinosaurs = 
    [| "Tyrannosaurus"
       "Amargasaurus"
       "Mamenchisaurus"
       "Brachiosaurus"
       "Deinonychus"
       "Tyrannosaurus"
       "Compsognathus" |]

printfn ""
for dino in dinosaurs do
    printfn $"{dino}"

Array.LastIndexOf(dinosaurs, "Tyrannosaurus")
|> printfn "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\"): %i"

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3)
|> printfn "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\", 3): %i"

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4)
|> printfn "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\", 4, 4): %i"

// This code example produces the following output:
//    
//    Tyrannosaurus
//    Amargasaurus
//    Mamenchisaurus
//    Brachiosaurus
//    Deinonychus
//    Tyrannosaurus
//    Compsognathus
//    
//    Array.LastIndexOf(dinosaurs, "Tyrannosaurus"): 5
//
//    Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3): 0
//
//    Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4): -1

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { "Tyrannosaurus", _
            "Amargasaurus", _
            "Mamenchisaurus", _
            "Brachiosaurus", _
            "Deinonychus", _
            "Tyrannosaurus", _
            "Compsognathus" }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "Array.LastIndexOf(dinosaurs, ""Tyrannosaurus""): {0}", _
            Array.LastIndexOf(dinosaurs, "Tyrannosaurus"))

        Console.WriteLine(vbLf & _
            "Array.LastIndexOf(dinosaurs, ""Tyrannosaurus"", 3): {0}", _
            Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3))

        Console.WriteLine(vbLf & _
            "Array.LastIndexOf(dinosaurs, ""Tyrannosaurus"", 4, 4): {0}", _
            Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4))

    End Sub
End Class

' This code example produces the following output:
'
'Tyrannosaurus
'Amargasaurus
'Mamenchisaurus
'Brachiosaurus
'Deinonychus
'Tyrannosaurus
'Compsognathus
'
'Array.LastIndexOf(dinosaurs, "Tyrannosaurus"): 5
'
'Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3): 0
'
'Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4): -1

Opmerkingen

Het Array wordt achterwaarts gezocht vanaf startIndex het eerste element en eindigt op het eerste element.

De elementen worden vergeleken met de opgegeven waarde met behulp van de Object.Equals methode. Als het elementtype een niet-intrinsisch (door de gebruiker gedefinieerd) type is, wordt de Equals implementatie van dat type gebruikt.

Deze methode is een O(n)-bewerking, waarbij n het aantal elementen van begin array tot startIndexen met .

Zie ook

Van toepassing op

LastIndexOf<T>(T[], T, Int32, Int32)

Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs
Bron:
Array.cs

Zoekt naar het opgegeven object en retourneert de index van het laatste exemplaar binnen het bereik van elementen in het Array opgegeven aantal elementen en eindigt op de opgegeven index.

public:
generic <typename T>
 static int LastIndexOf(cli::array <T> ^ array, T value, int startIndex, int count);
public static int LastIndexOf<T>(T[] array, T value, int startIndex, int count);
static member LastIndexOf : 'T[] * 'T * int * int -> int
Public Shared Function LastIndexOf(Of T) (array As T(), value As T, startIndex As Integer, count As Integer) As Integer

Type parameters

T

Het type van de elementen van de matrix.

Parameters

array
T[]

De eendimensionale, op nul gebaseerde Array zoekopdrachten.

value
T

Het object dat moet worden gevonden in array.

startIndex
Int32

De op nul gebaseerde beginindex van de achterwaartse zoekopdracht.

count
Int32

Het aantal elementen in de sectie dat moet worden gezocht.

Retouren

Int32

De op nul gebaseerde index van het laatste exemplaar van value binnen het bereik van elementen in array die het aantal elementen bevat dat is opgegeven en count eindigt op startIndex, indien gevonden; anders -1.

Uitzonderingen

ArgumentNullException

array is null.

ArgumentOutOfRangeException

startIndex valt buiten het bereik van geldige indexen voor array.

– of –

count is kleiner dan nul.

– of –

startIndex en count geef geen geldige sectie op in array.

Voorbeelden

In het volgende codevoorbeeld ziet u alle drie algemene overbelastingen van de LastIndexOf methode. Er wordt een matrix met tekenreeksen gemaakt, met één vermelding die tweemaal wordt weergegeven, op indexlocatie 0 en indexlocatie 5. De LastIndexOf<T>(T[], T) overbelasting van de methode doorzoekt de hele matrix vanaf het einde en zoekt het tweede exemplaar van de tekenreeks. De LastIndexOf<T>(T[], T, Int32) overbelasting van de methode wordt gebruikt om de matrix achterwaarts te doorzoeken vanaf indexlocatie 3 en door te gaan naar het begin van de matrix en het eerste exemplaar van de tekenreeks te vinden. Ten slotte wordt de overbelasting van de LastIndexOf<T>(T[], T, Int32, Int32) methode gebruikt om een bereik van vier vermeldingen te doorzoeken, te beginnen bij indexlocatie 4 en achteruit uit te breiden (dat wil gezegd, het doorzoekt de items op locaties 4, 3, 2 en 1); deze zoekopdracht retourneert -1 omdat er geen exemplaren van de zoekreeks in dat bereik zijn.

string[] dinosaurs = { "Tyrannosaurus",
    "Amargasaurus",
    "Mamenchisaurus",
    "Brachiosaurus",
    "Deinonychus",
    "Tyrannosaurus",
    "Compsognathus" };

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

Console.WriteLine(
    "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\"): {0}",
    Array.LastIndexOf(dinosaurs, "Tyrannosaurus"));

Console.WriteLine(
    "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\", 3): {0}",
    Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3));

Console.WriteLine(
    "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\", 4, 4): {0}",
    Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4));

/* This code example produces the following output:

Tyrannosaurus
Amargasaurus
Mamenchisaurus
Brachiosaurus
Deinonychus
Tyrannosaurus
Compsognathus

Array.LastIndexOf(dinosaurs, "Tyrannosaurus"): 5

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3): 0

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4): -1
*/

open System

let dinosaurs = 
    [| "Tyrannosaurus"
       "Amargasaurus"
       "Mamenchisaurus"
       "Brachiosaurus"
       "Deinonychus"
       "Tyrannosaurus"
       "Compsognathus" |]

printfn ""
for dino in dinosaurs do
    printfn $"{dino}"

Array.LastIndexOf(dinosaurs, "Tyrannosaurus")
|> printfn "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\"): %i"

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3)
|> printfn "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\", 3): %i"

Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4)
|> printfn "\nArray.LastIndexOf(dinosaurs, \"Tyrannosaurus\", 4, 4): %i"

// This code example produces the following output:
//    
//    Tyrannosaurus
//    Amargasaurus
//    Mamenchisaurus
//    Brachiosaurus
//    Deinonychus
//    Tyrannosaurus
//    Compsognathus
//    
//    Array.LastIndexOf(dinosaurs, "Tyrannosaurus"): 5
//
//    Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3): 0
//
//    Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4): -1

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { "Tyrannosaurus", _
            "Amargasaurus", _
            "Mamenchisaurus", _
            "Brachiosaurus", _
            "Deinonychus", _
            "Tyrannosaurus", _
            "Compsognathus" }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "Array.LastIndexOf(dinosaurs, ""Tyrannosaurus""): {0}", _
            Array.LastIndexOf(dinosaurs, "Tyrannosaurus"))

        Console.WriteLine(vbLf & _
            "Array.LastIndexOf(dinosaurs, ""Tyrannosaurus"", 3): {0}", _
            Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3))

        Console.WriteLine(vbLf & _
            "Array.LastIndexOf(dinosaurs, ""Tyrannosaurus"", 4, 4): {0}", _
            Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4))

    End Sub
End Class

' This code example produces the following output:
'
'Tyrannosaurus
'Amargasaurus
'Mamenchisaurus
'Brachiosaurus
'Deinonychus
'Tyrannosaurus
'Compsognathus
'
'Array.LastIndexOf(dinosaurs, "Tyrannosaurus"): 5
'
'Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 3): 0
'
'Array.LastIndexOf(dinosaurs, "Tyrannosaurus", 4, 4): -1

Opmerkingen

De Array zoekopdracht begint achterwaarts bij startIndex en eindigt op startIndex min count plus 1, als count deze groter is dan 0.

De elementen worden vergeleken met de opgegeven waarde met behulp van de Object.Equals methode. Als het elementtype een niet-intrinsisch (door de gebruiker gedefinieerd) type is, wordt de Equals implementatie van dat type gebruikt.

Deze methode is een O(n)-bewerking, waarbij n .count

Zie ook

Van toepassing op