Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

Array.LastIndexOf-Methode: (Array, Object, Int32)

 

Veröffentlicht: Oktober 2016

Sucht nach dem angegebenen Objekt und gibt den Index des letzten Vorkommens innerhalb des Bereichs von Elementen im eindimensionalen Array zurück, das sich vom ersten Element bis zum angegebenen Index erstreckt.

Namespace:   System
Assembly:  mscorlib (in mscorlib.dll)

public static int LastIndexOf(
	Array array,
	object value,
	int startIndex
)

Parameter

array
Type: System.Array

Das zu durchsuchende eindimensionale Array.

value
Type: System.Object

Das in array zu suchende Objekt.

startIndex
Type: System.Int32

Der Startindex für die Rückwärtssuche.

Rückgabewert

Type: System.Int32

Der Index des letzten Vorkommens von value innerhalb des Bereichs von Elementen im array, das sich vom ersten Element bis zum startIndex erstreckt, sofern gefunden, andernfalls die untere Grenze des Arrays minus 1.

Exception Condition
ArgumentNullException

array ist null.

ArgumentOutOfRangeException

startIndex liegt außerhalb des Bereichs der gültigen Indizes für array.

RankException

array ist mehrdimensional.

Das eindimensionale Array wird rückwärts durchsucht, wobei die Suche am startIndex und endet beim ersten Element.

Die Elemente werden verglichen, um den angegebenen Wert mit der Object.Equals Methode. Wenn der Elementtyp kein systeminterner (Benutzerdefiniert) Typ ist der Equals Implementierung dieses Typs verwendet.

Da die meisten Arrays mit eine unteren Grenze von 0 (null) hat, wird diese Methode im Allgemeinen – 1 bei zurück value wurde nicht gefunden. In dem seltenen Fall, das die untere Grenze des Arrays gleich Int32.MinValue und value nicht gefunden wird, gibt diese Methode Int32.MaxValue, also System.Int32.MinValue - 1.

Diese Methode ist eine O (n)-Vorgang, in dem n ist die Anzahl der Elemente vom Anfang des array auf startIndex.

In .NET Framework, Version 2.0, verwendet diese Methode die Equals und CompareTo Methoden die Array um zu bestimmen, ob die Object anhand der value Parameter vorhanden ist. In früheren Versionen von .NET Framework wurden mithilfe der Equals und CompareTo Methoden die valueObject selbst.

Im folgenden Codebeispiel wird veranschaulicht, wie den Index des letzten Vorkommens eines angegebenen Elements in einem Array bestimmt.

using System;
public class SamplesArray  {

   public static void Main()  {

      // 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 );
   }


   public static void PrintIndexAndValues( Array myArray )  {
      for ( int i = myArray.GetLowerBound(0); i <= myArray.GetUpperBound(0); i++ )
         Console.WriteLine( "\t[{0}]:\t{1}", i, myArray.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.
*/

Universelle Windows-Plattform
Verfügbar seit 8
.NET Framework
Verfügbar seit 1.1
Portierbare Klassenbibliothek
Unterstützt in: portierbare .NET-Plattformen
Windows Phone Silverlight
Verfügbar seit 8.0
Windows Phone
Verfügbar seit 8.1
Zurück zum Anfang
Anzeigen: