Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Método Array.LastIndexOf (Array, Object, Int32)

 

Publicado: octubre de 2016

Busca el objeto especificado y devuelve el índice de la última aparición en el intervalo de elementos de la matriz Array unidimensional que se extiende desde el primer elemento hasta el índice especificado.

Espacio de nombres:   System
Ensamblado:  mscorlib (en mscorlib.dll)

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

Parámetros

array
Type: System.Array

Array unidimensional en la que se va a buscar.

value
Type: System.Object

Objeto que se va a buscar en array.

startIndex
Type: System.Int32

Índice inicial de la búsqueda hacia atrás.

Valor devuelto

Type: System.Int32

Índice de la última aparición de value en el intervalo de elementos de array que se extiende desde el primer elemento hasta startIndex, si se encuentra; en caso contrario, límite inferior de la matriz menos 1.

Exception Condition
ArgumentNullException

El valor de array es null.

ArgumentOutOfRangeException

startIndex está fuera del intervalo de índices válidos para array.

RankException

array es multidimensional.

Unidimensional Array es la búsqueda hacia atrás empezando en startIndex y terminando en el primer elemento.

Los elementos se comparan con el valor especificado mediante el Object.Equals método. Si el tipo de elemento es un tipo no intrínseco (definido por el usuario), el Equals se utiliza la implementación de ese tipo.

Como la mayoría de las matrices tienen un límite inferior de cero, este método normalmente devuelve-1 cuando value no se encuentra. En el caso excepcional de que el límite inferior de la matriz es igual a Int32.MinValue y value no se encuentra, este método devuelve Int32.MaxValue, que es System.Int32.MinValue - 1.

Este método es una O (n) operación, donde n es el número de elementos desde el principio de array a startIndex.

En la versión 2.0 de .NET Framework, este método utiliza el Equals y CompareTo métodos de la Array para determinar si el Object especificado por el value existe un parámetro. En las versiones anteriores de .NET Framework, esta determinación se realizó utilizando la Equals y CompareTo métodos de la valueObject propio.

En el ejemplo de código siguiente se muestra cómo determinar el índice de la última aparición de un elemento especificado en una matriz.

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

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Windows Phone Silverlight
Disponible desde 8.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: