Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Metodo Array.LastIndexOf (Array, Object, Int32)

 

Data di pubblicazione: ottobre 2016

Cerca l'oggetto specificato e restituisce l'indice dell'ultima occorrenza all'interno dell'intervallo di elementi dell'oggetto Array unidimensionale compreso tra il primo elemento e l'indice specificato.

Spazio dei nomi:   System
Assembly:  mscorlib (in mscorlib.dll)

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

Parametri

array
Type: System.Array

Oggetto Array unidimensionale in cui eseguire la ricerca.

value
Type: System.Object

Oggetto da trovare in array.

startIndex
Type: System.Int32

Indice iniziale della ricerca all'indietro.

Valore restituito

Type: System.Int32

Indice della prima occorrenza del valore indicato nel parametro value all'interno dell'intervallo di elementi della matrice array compreso tra il primo elemento e l'indice startIndex, se trovato; in caso contrario, verrà restituito il limite inferiore della matrice meno 1.

Exception Condition
ArgumentNullException

array è null.

ArgumentOutOfRangeException

startIndex non è compreso nell'intervallo di indici validi per array.

RankException

array è multidimensionale.

Oggetto unidimensionale Array viene eseguita con le versioni precedenti a partire dall'indice startIndex e termina in corrispondenza del primo elemento.

Gli elementi vengono confrontati con il valore specificato utilizzando il Object.Equals metodo. Se il tipo di elemento è un tipo non intrinseco (definito dall'utente), il Equals viene utilizzata l'implementazione di tale tipo.

Poiché la maggior parte delle matrici avrà un limite inferiore pari a zero, questo metodo in genere restituirà-1 se value non viene trovato. Nel raro caso in cui il limite inferiore della matrice è uguale a Int32.MinValue e value non viene trovato, questo metodo restituisce Int32.MaxValue, ovvero System.Int32.MinValue - 1.

Questo metodo è un'operazione O (n) operazione, in cui n è il numero di elementi dall'inizio del array a startIndex.

In .NET Framework versione 2.0, questo metodo utilizza il Equals e CompareTo metodi il Array per determinare se il Object specificato dal value parametro esiste. Nelle versioni precedenti di .NET Framework, questa operazione è stata effettuata utilizzando il Equals e CompareTo metodi il valueObject stesso.

Esempio di codice seguente viene illustrato come determinare l'indice dell'ultima occorrenza di un elemento specificato in una matrice.

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.
*/

Universal Windows Platform
Disponibile da 8
.NET Framework
Disponibile da 1.1
Libreria di classi portabile
Supportato in: piattaforme .NET portabili
Windows Phone Silverlight
Disponibile da 8.0
Windows Phone
Disponibile da 8.1
Torna all'inizio
Mostra: