Array Array Array Array Class

Definición

Proporciona métodos para la creación, manipulación, búsqueda y ordenación de matrices, por lo tanto, sirve como clase base para todas las matrices de Common Language Runtime.Provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the base class for all arrays in the common language runtime.

public ref class Array abstract : ICloneable, System::Collections::IList, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public abstract class Array : ICloneable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
type Array = class
    interface ICloneable
    interface ICollection
    interface IList
    interface IEnumerable
    interface IStructuralComparable
    interface IStructuralEquatable
Public MustInherit Class Array
Implements ICloneable, IList, IStructuralComparable, IStructuralEquatable
Herencia
ArrayArrayArrayArray
Atributos
Implementaciones

Ejemplos

El siguiente ejemplo de código muestra cómo Array.Copy copia elementos entre una matriz de tipo entero y una matriz de tipo Object.The following code example shows how Array.Copy copies elements between an array of type integer and an array of type Object.

using namespace System;

void PrintValues(array<Object^>^myArr);
void PrintValues(array<int>^myArr);
void main()
{
	// Creates and initializes a new int array and a new Object array.
	array<int>^myIntArray = { 1,2,3,4,5 };
	array<Object^>^myObjArray = { 26,27,28,29,30 };

	// Prints the initial values of both arrays.
	Console::WriteLine("Initially:");
	Console::Write("int array:   ");
	PrintValues(myIntArray);
	Console::Write("Object array:");
	PrintValues(myObjArray);

	// Copies the first two elements from the int array to the Object array.
	System::Array::Copy(myIntArray, myObjArray, 2);

	// Prints the values of the modified arrays.
	Console::WriteLine("\nAfter copying the first two elements of the int array to the Object array:");
	Console::Write("int array:   ");
	PrintValues(myIntArray);
	Console::Write("Object array:");
	PrintValues(myObjArray);

	// Copies the last two elements from the Object array to the int array.
	System::Array::Copy(myObjArray, myObjArray->GetUpperBound(0) - 1, myIntArray, myIntArray->GetUpperBound(0) - 1, 2);

	// Prints the values of the modified arrays.
	Console::WriteLine("\nAfter copying the last two elements of the Object array to the int array:");
	Console::Write("int array:   ");
	PrintValues(myIntArray);
	Console::Write("Object array:");
	PrintValues(myObjArray);
}

void PrintValues(array<Object^>^myArr)
{
	for (int i = 0; i < myArr->Length; i++)
	{
		Console::Write("\t{0}", myArr[i]);

	}
	Console::WriteLine();
}

void PrintValues(array<int>^myArr)
{
	for (int i = 0; i < myArr->Length; i++)
	{
		Console::Write("\t{0}", myArr[i]);

	}
	Console::WriteLine();
}


/*
This code produces the following output.

Initially:
int array:       1    2    3    4    5
Object array:    26    27    28    29    30
After copying the first two elements of the int array to the Object array:
int array:       1    2    3    4    5
Object array:    1    2    28    29    30
After copying the last two elements of the Object array to the int array:
int array:       1    2    3    29    30
Object array:    1    2    28    29    30
*/
using System;
public class SamplesArray  {
 
    public static void Main()  {
 
       // Creates and initializes a new integer array and a new Object array.
       int[] myIntArray = new int[5] { 1, 2, 3, 4, 5 };
       Object[] myObjArray = new Object[5] { 26, 27, 28, 29, 30 };
 
       // Prints the initial values of both arrays.
       Console.WriteLine( "Initially," );
       Console.Write( "integer array:" );
       PrintValues( myIntArray );
       Console.Write( "Object array: " );
       PrintValues( myObjArray );
 
       // Copies the first two elements from the integer array to the Object array.
       System.Array.Copy( myIntArray, myObjArray, 2 );
 
       // Prints the values of the modified arrays.
       Console.WriteLine( "\nAfter copying the first two elements of the integer array to the Object array," );
       Console.Write( "integer array:" );
       PrintValues( myIntArray );
       Console.Write( "Object array: " );
       PrintValues( myObjArray );
 
       // Copies the last two elements from the Object array to the integer array.
       System.Array.Copy( myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, myIntArray.GetUpperBound(0) - 1, 2 );
 
       // Prints the values of the modified arrays.
       Console.WriteLine( "\nAfter copying the last two elements of the Object array to the integer array," );
       Console.Write( "integer array:" );
       PrintValues( myIntArray );
       Console.Write( "Object array: " );
       PrintValues( myObjArray );
    }
 
 
    public static void PrintValues( Object[] myArr )  {
       foreach ( Object i in myArr )  {
          Console.Write( "\t{0}", i );
       }
       Console.WriteLine();
    }
 
    public static void PrintValues( int[] myArr )  {
       foreach ( int i in myArr )  {
          Console.Write( "\t{0}", i );
       }
       Console.WriteLine();
    }
 }
 /* 
 This code produces the following output.
 
 Initially,
 integer array:  1       2       3       4       5
 Object array:   26      27      28      29      30

 After copying the first two elements of the integer array to the Object array,
 integer array:  1       2       3       4       5
 Object array:   1       2       28      29      30

 After copying the last two elements of the Object array to the integer array,
 integer array:  1       2       3       29      30
 Object array:   1       2       28      29      30
 */
Public Class SamplesArray

    Public Shared Sub Main()

        ' Creates and initializes a new integer array and a new Object array.
        Dim myIntArray() As Integer = {1, 2, 3, 4, 5}
        Dim myObjArray() As Object = {26, 27, 28, 29, 30}

        ' Prints the initial values of both arrays.
        Console.WriteLine("Initially:")
        Console.Write("integer array:")
        PrintValues(myIntArray)
        Console.Write("Object array: ")
        PrintValues(myObjArray)

        ' Copies the first two elements from the integer array to the Object array.
        System.Array.Copy(myIntArray, myObjArray, 2)

        ' Prints the values of the modified arrays.
        Console.WriteLine(ControlChars.NewLine + "After copying the first two" _
           + " elements of the integer array to the Object array:")
        Console.Write("integer array:")
        PrintValues(myIntArray)
        Console.Write("Object array: ")
        PrintValues(myObjArray)

        ' Copies the last two elements from the Object array to the integer array.
        System.Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray,
           myIntArray.GetUpperBound(0) - 1, 2)

        ' Prints the values of the modified arrays.
        Console.WriteLine(ControlChars.NewLine + "After copying the last two" _
           + " elements of the Object array to the integer array:")
        Console.Write("integer array:")
        PrintValues(myIntArray)
        Console.Write("Object array: ")
        PrintValues(myObjArray)
    End Sub

    Public Overloads Shared Sub PrintValues(myArr() As Object)
        Dim i As Object
        For Each i In myArr
            Console.Write(ControlChars.Tab + "{0}", i)
        Next i
        Console.WriteLine()
    End Sub

    Public Overloads Shared Sub PrintValues(myArr() As Integer)
        Dim i As Integer
        For Each i In myArr
            Console.Write(ControlChars.Tab + "{0}", i)
        Next i
        Console.WriteLine()
    End Sub
End Class

' This code produces the following output.
' 
' Initially:
' integer array:  1       2       3       4       5
' Object array:   26      27      28      29      30
' 
' After copying the first two elements of the integer array to the Object array:
' integer array:  1       2       3       4       5
' Object array:   1       2       28      29      30
' 
' After copying the last two elements of the Object array to the integer array:
' integer array:  1       2       3       29      30
' Object array:   1       2       28      29      30

En el ejemplo de código siguiente se crea e inicializa un Array y muestra sus propiedades y sus elementos.The following code example creates and initializes an Array and displays its properties and its elements.

using namespace System;
void PrintValues(Array^ myArr);
void main()
{
   // Creates and initializes a new three-dimensional Array instance of type Int32.
   Array^ myArr = Array::CreateInstance( Int32::typeid, 2, 3, 4 );
   for ( int i = myArr->GetLowerBound( 0 ); i <= myArr->GetUpperBound( 0 ); i++ )
   {
      for ( int j = myArr->GetLowerBound( 1 ); j <= myArr->GetUpperBound( 1 ); j++ )
      {
         for ( int k = myArr->GetLowerBound( 2 ); k <= myArr->GetUpperBound( 2 ); k++ )
            myArr->SetValue( (i * 100) + (j * 10) + k, i, j, k );

      }
   }
   
   // Displays the properties of the Array.
   Console::WriteLine(  "The Array instance has {0} dimension(s) and a total of {1} elements.", myArr->Rank, myArr->Length );
   Console::WriteLine(  "\tLength\tLower\tUpper" );
   for ( int i = 0; i < myArr->Rank; i++ )
   {
      Console::Write(  "{0}:\t{1}", i, myArr->GetLength( i ) );
      Console::WriteLine(  "\t{0}\t{1}", myArr->GetLowerBound( i ), myArr->GetUpperBound( i ) );

   }
   Console::WriteLine(  "The Array instance contains the following values:" );
   PrintValues( myArr );
}

void PrintValues( Array^ myArr )
{
   System::Collections::IEnumerator^ myEnumerator = myArr->GetEnumerator();
   int i = 0;
   int cols = myArr->GetLength( myArr->Rank - 1 );
   while ( myEnumerator->MoveNext() )
   {
      if ( i < cols )
            i++;
      else
      {
         Console::WriteLine();
         i = 1;
      }

      Console::Write(  "\t{0}", myEnumerator->Current );
   }

   Console::WriteLine();
}

/* 
 This code produces the following output.
 
 The Array instance has 3 dimension(s) and a total of 24 elements.
     Length    Lower    Upper
 0:    2    0    1
 1:    3    0    2
 2:    4    0    3
 The Array instance contains the following values:
     0    1    2    3
     10    11    12    13
     20    21    22    23
     100    101    102    103
     110    111    112    113
     120    121    122    123
 */
using System;
public class SamplesArray2{
 
    public static void Main()  {
 
       // Creates and initializes a new three-dimensional Array of type Int32.
       Array myArr = Array.CreateInstance( typeof(Int32), 2, 3, 4 );
       for ( int i = myArr.GetLowerBound(0); i <= myArr.GetUpperBound(0); i++ )
          for ( int j = myArr.GetLowerBound(1); j <= myArr.GetUpperBound(1); j++ )
             for ( int k = myArr.GetLowerBound(2); k <= myArr.GetUpperBound(2); k++ )  {
                myArr.SetValue( (i*100)+(j*10)+k, i, j, k );
             }
 
       // Displays the properties of the Array.
       Console.WriteLine( "The Array has {0} dimension(s) and a total of {1} elements.", myArr.Rank, myArr.Length );
       Console.WriteLine( "\tLength\tLower\tUpper" );
       for ( int i = 0; i < myArr.Rank; i++ )  {
          Console.Write( "{0}:\t{1}", i, myArr.GetLength(i) );
          Console.WriteLine( "\t{0}\t{1}", myArr.GetLowerBound(i), myArr.GetUpperBound(i) );
       }
 
       // Displays the contents of the Array.
       Console.WriteLine( "The Array contains the following values:" );
       PrintValues( myArr );
    }
 
 
    public static void PrintValues( Array myArr )  {
       System.Collections.IEnumerator myEnumerator = myArr.GetEnumerator();
       int i = 0;
       int cols = myArr.GetLength( myArr.Rank - 1 );
       while ( myEnumerator.MoveNext() )  {
          if ( i < cols )  {
             i++;
          } else  {
             Console.WriteLine();
             i = 1;
          }
          Console.Write( "\t{0}", myEnumerator.Current );
       }
       Console.WriteLine();
    }
 }
 /* 
 This code produces the following output.
 
 The Array has 3 dimension(s) and a total of 24 elements.
     Length    Lower    Upper
 0:    2    0    1
 1:    3    0    2
 2:    4    0    3
 The Array contains the following values:
     0    1    2    3
     10    11    12    13
     20    21    22    23
     100    101    102    103
     110    111    112    113
     120    121    122    123
 */
Public Class SamplesArray2

    Public Shared Sub Main()

        ' Creates and initializes a new three-dimensional Array of
        ' type Int32.
        Dim myArr As Array = Array.CreateInstance(GetType(Int32), 2, 3, 4)
        Dim i As Integer
        For i = myArr.GetLowerBound(0) To myArr.GetUpperBound(0)
            Dim j As Integer
            For j = myArr.GetLowerBound(1) To myArr.GetUpperBound(1)
                Dim k As Integer
                For k = myArr.GetLowerBound(2) To myArr.GetUpperBound(2)
                    myArr.SetValue(i * 100 + j * 10 + k, i, j, k)
                Next k
            Next j
        Next i ' Displays the properties of the Array.
        Console.WriteLine("The Array has {0} dimension(s) and a " _
           + "total of {1} elements.", myArr.Rank, myArr.Length)
        Console.WriteLine(ControlChars.Tab + "Length" + ControlChars.Tab _
           + "Lower" + ControlChars.Tab + "Upper")
        For i = 0 To myArr.Rank - 1
            Console.Write("{0}:" + ControlChars.Tab + "{1}", i,
               myArr.GetLength(i))
            Console.WriteLine(ControlChars.Tab + "{0}" + ControlChars.Tab _
               + "{1}", myArr.GetLowerBound(i), myArr.GetUpperBound(i))
        Next i

        ' Displays the contents of the Array.
        Console.WriteLine("The Array contains the following values:")
        PrintValues(myArr)
    End Sub

    Public Shared Sub PrintValues(myArr As Array)
        Dim myEnumerator As System.Collections.IEnumerator =
           myArr.GetEnumerator()
        Dim i As Integer = 0
        Dim cols As Integer = myArr.GetLength(myArr.Rank - 1)
        While myEnumerator.MoveNext()
            If i < cols Then
                i += 1
            Else
                Console.WriteLine()
                i = 1
            End If
            Console.Write(ControlChars.Tab + "{0}", myEnumerator.Current)
        End While
        Console.WriteLine()
    End Sub
End Class

' This code produces the following output.
' 
' The Array has 3 dimension(s) and a total of 24 elements.
'     Length    Lower    Upper
' 0:    2    0    1
' 1:    3    0    2
' 2:    4    0    3
' The Array contains the following values:
'     0    1    2    3
'     10    11    12    13
'     20    21    22    23
'     100    101    102    103
'     110    111    112    113
'     120    121    122    123 

Comentarios

El Array clase no es parte de la System.Collections espacios de nombres.The Array class is not part of the System.Collections namespaces. Sin embargo, todavía se considera una colección porque se basa en el IList interfaz.However, it is still considered a collection because it is based on the IList interface.

La Array clase es la clase base para las implementaciones de lenguajes que admiten las matrices.The Array class is the base class for language implementations that support arrays. Sin embargo, el sistema y los compiladores pueden derivar explícitamente de la Array clase.However, only the system and compilers can derive explicitly from the Array class. Los usuarios deben utilizar los constructores de matriz proporcionados por el lenguaje.Users should employ the array constructs provided by the language.

Un elemento es un valor en un Array.An element is a value in an Array. La longitud de un Array es el número total de elementos que puede contener.The length of an Array is the total number of elements it can contain. El límite inferior de un Array es el índice de su primer elemento.The lower bound of an Array is the index of its first element. Un Array puede tener cualquier límite inferior, pero tiene un límite inferior de cero de forma predeterminada.An Array can have any lower bound, but it has a lower bound of zero by default. Se puede definir un límite inferior diferente al crear una instancia de la Array mediante la clase CreateInstance. Multidimensional Array puede tener distintos límites para cada dimensión.A different lower bound can be defined when creating an instance of the Array class using CreateInstance.A multidimensional Array can have different bounds for each dimension. Una matriz puede tener un máximo de 32 dimensiones.An array can have a maximum of 32 dimensions.

A diferencia de las clases en el System.Collections espacios de nombres, Array tiene una capacidad fija.Unlike the classes in the System.Collections namespaces, Array has a fixed capacity. Para aumentar la capacidad, debe crear un nuevo Array objetos con la capacidad requerida, copiar los elementos de la antigua Array objeto a la nueva y eliminar la antigua Array.To increase the capacity, you must create a new Array object with the required capacity, copy the elements from the old Array object to the new one, and delete the old Array.

De forma predeterminada, el tamaño máximo de un Array es de 2 gigabytes (GB).By default, the maximum size of an Array is 2 gigabytes (GB). En un entorno de 64 bits, puede evitar la restricción de tamaño estableciendo el enabled atributo de la gcAllowVeryLargeObjects elemento de configuración a true en el entorno de tiempo de ejecución.In a 64-bit environment, you can avoid the size restriction by setting the enabled attribute of the gcAllowVeryLargeObjects configuration element to true in the run-time environment. Sin embargo, la matriz todavía estará limitada a un total de elementos de 4 mil millones y a un índice máximo de 0X7FEFFFFF en cualquier dimensión determinada (0X7FFFFFC7 para las matrices de bytes y matrices de estructuras de byte único).However, the array will still be limited to a total of 4 billion elements, and to a maximum index of 0X7FEFFFFF in any given dimension (0X7FFFFFC7 for byte arrays and arrays of single-byte structures).

Las matrices unidimensionales implementan la System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyList<T> y System.Collections.Generic.IReadOnlyCollection<T> interfaces genéricas.Single-dimensional arrays implement the System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyList<T> and System.Collections.Generic.IReadOnlyCollection<T> generic interfaces. Las implementaciones se proporcionan a las matrices en tiempo de ejecución y, como resultado, las interfaces genéricas no aparecen en la sintaxis de declaración para el Array clase.The implementations are provided to arrays at run time, and as a result, the generic interfaces do not appear in the declaration syntax for the Array class. Además, no hay ningún temas de referencia para los miembros de interfaz que se puede acceder solo mediante la conversión de una matriz para el tipo de interfaz genérica (implementaciones de interfaz explícitas).In addition, there are no reference topics for interface members that are accessible only by casting an array to the generic interface type (explicit interface implementations). El aspecto clave a tener en cuenta al convertir una matriz a una de estas interfaces es que los miembros que permiten agregar, insertar o quitar elementos throw NotSupportedException.The key thing to be aware of when you cast an array to one of these interfaces is that members which add, insert, or remove elements throw NotSupportedException.

Type objetos proporcionan información acerca de las declaraciones de tipo de matriz.Type objects provide information about array type declarations. Array los objetos con el mismo tipo de matriz comparten el mismo Type objeto.Array objects with the same array type share the same Type object.

Type.IsArray y Type.GetElementType no puede devolver los resultados esperados con Array porque si una matriz se convierte al tipo Array, el resultado es un objeto, no es una matriz.Type.IsArray and Type.GetElementType might not return the expected results with Array because if an array is cast to the type Array, the result is an object, not an array. Es decir, typeof(System.Array).IsArray devuelve false, y typeof(System.Array).GetElementType devuelve null.That is, typeof(System.Array).IsArray returns false, and typeof(System.Array).GetElementType returns null.

El Array.Copy método copia elementos no sólo entre matrices del mismo tipo, sino también entre matrices estándar de tipos diferentes, ya que controla automáticamente la conversión de tipos.The Array.Copy method copies elements not only between arrays of the same type but also between standard arrays of different types; it handles type casting automatically.

Algunos métodos, como CreateInstance, Copy, CopyTo, GetValue, y SetValue, proporcionan sobrecargas que aceptan enteros de 64 bits como parámetros para dar cabida a las matrices de gran capacidad.Some methods, such as CreateInstance, Copy, CopyTo, GetValue, and SetValue, provide overloads that accept 64-bit integers as parameters to accommodate large capacity arrays. LongLength y GetLongLength devuelven enteros de 64 bits que indica la longitud de la matriz.LongLength and GetLongLength return 64-bit integers indicating the length of the array.

El Array no se garantiza que se va a ordenar.The Array is not guaranteed to be sorted. Se debe ordenar el Array antes de realizar operaciones (como BinarySearch) que requieren el Array esté ordenada.You must sort the Array prior to performing operations (such as BinarySearch) that require the Array to be sorted.

Mediante un Array no admite el objeto de punteros en código nativo y se producirá un NotSupportedException para varios métodos.Using an Array object of pointers in native code is not supported and will throw a NotSupportedException for several methods.

Propiedades

IsFixedSize IsFixedSize IsFixedSize IsFixedSize

Obtiene un valor que indica si la interfaz Array tiene un tamaño fijo.Gets a value indicating whether the Array has a fixed size.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Obtiene un valor que indica si Array es de solo lectura.Gets a value indicating whether the Array is read-only.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

Obtiene un valor que indica si el acceso a la interfaz Array está sincronizado (es seguro para subprocesos).Gets a value indicating whether access to the Array is synchronized (thread safe).

Length Length Length Length

Obtiene el número total de elementos de todas las dimensiones de Array.Gets the total number of elements in all the dimensions of the Array.

LongLength LongLength LongLength LongLength

Obtiene un entero de 64 bits que representa el número total de elementos de todas las dimensiones de Array.Gets a 64-bit integer that represents the total number of elements in all the dimensions of the Array.

Rank Rank Rank Rank

Obtiene el rango (número de dimensiones) de Array.Gets the rank (number of dimensions) of the Array. Por ejemplo, una matriz unidimensional devuelve 1, una matriz bidimensional devuelve 2, y así sucesivamente.For example, a one-dimensional array returns 1, a two-dimensional array returns 2, and so on.

SyncRoot SyncRoot SyncRoot SyncRoot

Obtiene un objeto que se puede usar para sincronizar el acceso a Array.Gets an object that can be used to synchronize access to the Array.

Métodos

AsReadOnly<T>(T[]) AsReadOnly<T>(T[]) AsReadOnly<T>(T[]) AsReadOnly<T>(T[])

Devuelve un contenedor de solo lectura para la matriz especificada.Returns a read-only wrapper for the specified array.

BinarySearch(Array, Int32, Int32, Object) BinarySearch(Array, Int32, Int32, Object) BinarySearch(Array, Int32, Int32, Object) BinarySearch(Array, Int32, Int32, Object)

Busca un valor en un intervalo de elementos de una matriz unidimensional y ordenada, usando la interfaz IComparable implementada por cada elemento de la matriz y por el valor especificado.Searches a range of elements in a one-dimensional sorted array for a value, using the IComparable interface implemented by each element of the array and by the specified value.

BinarySearch(Array, Int32, Int32, Object, IComparer) BinarySearch(Array, Int32, Int32, Object, IComparer) BinarySearch(Array, Int32, Int32, Object, IComparer) BinarySearch(Array, Int32, Int32, Object, IComparer)

Busca un valor en un intervalo de elementos de una matriz unidimensional y ordenada, usando la interfaz IComparer especificada.Searches a range of elements in a one-dimensional sorted array for a value, using the specified IComparer interface.

BinarySearch(Array, Object) BinarySearch(Array, Object) BinarySearch(Array, Object) BinarySearch(Array, Object)

Busca un elemento específico en toda una matriz unidimensional y ordenada, usando la interfaz IComparable implementada por cada elemento de la matriz y por el objeto especificado.Searches an entire one-dimensional sorted array for a specific element, using the IComparable interface implemented by each element of the array and by the specified object.

BinarySearch(Array, Object, IComparer) BinarySearch(Array, Object, IComparer) BinarySearch(Array, Object, IComparer) BinarySearch(Array, Object, IComparer)

Busca un valor por toda una matriz unidimensional y ordenada, usando la interfaz IComparer especificada.Searches an entire one-dimensional sorted array for a value using the specified IComparer interface.

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

Busca un valor en un intervalo de elementos de una matriz unidimensional y ordenada, usando la interfaz genérica IComparable<T> que implementan cada elemento de Array y el valor especificado.Searches a range of elements in a one-dimensional sorted array for a value, using the IComparable<T> generic interface implemented by each element of the Array and by the specified value.

BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>) BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>) BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>) BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)

Busca un valor en un intervalo de elementos de una matriz unidimensional y ordenada, usando la interfaz genérica IComparer<T> especificada.Searches a range of elements in a one-dimensional sorted array for a value, using the specified IComparer<T> generic interface.

BinarySearch<T>(T[], T) BinarySearch<T>(T[], T) BinarySearch<T>(T[], T) BinarySearch<T>(T[], T)

Busca un elemento específico en una matriz unidimensional ordenada completa, usando la interfaz genérica IComparable<T> que implementan cada elemento de Array y el objeto especificado.Searches an entire one-dimensional sorted array for a specific element, using the IComparable<T> generic interface implemented by each element of the Array and by the specified object.

BinarySearch<T>(T[], T, IComparer<T>) BinarySearch<T>(T[], T, IComparer<T>) BinarySearch<T>(T[], T, IComparer<T>) BinarySearch<T>(T[], T, IComparer<T>)

Busca un valor por toda una matriz unidimensional y ordenada, usando la interfaz genérica IComparer<T> especificada.Searches an entire one-dimensional sorted array for a value using the specified IComparer<T> generic interface.

Clear(Array, Int32, Int32) Clear(Array, Int32, Int32) Clear(Array, Int32, Int32) Clear(Array, Int32, Int32)

Establece un intervalo de elementos de una matriz en el valor predeterminado de cada tipo de elemento.Sets a range of elements in an array to the default value of each element type.

Clone() Clone() Clone() Clone()

Crea una copia superficial de la colección Array.Creates a shallow copy of the Array.

ConstrainedCopy(Array, Int32, Array, Int32, Int32) ConstrainedCopy(Array, Int32, Array, Int32, Int32) ConstrainedCopy(Array, Int32, Array, Int32, Int32) ConstrainedCopy(Array, Int32, Array, Int32, Int32)

Copia un intervalo de elementos de un objeto Array a partir del índice de origen especificado y los pega en otro objeto Array a partir del índice de destino especificado.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. Garantiza que se deshacen todos los cambios si la copia no se realiza de forma totalmente correcta.Guarantees that all changes are undone if the copy does not succeed completely.

ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>) ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>) ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>) ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>)

Convierte una matriz de un tipo en una matriz de otro tipo.Converts an array of one type to an array of another type.

Copy(Array, Array, Int32) Copy(Array, Array, Int32) Copy(Array, Array, Int32) Copy(Array, Array, Int32)

Copia un intervalo de elementos de una matriz Array comenzando en el primer elemento y los pega en otra matriz Array comenzando en el primer elemento.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. La longitud se especifica como un entero de 32 bits.The length is specified as a 32-bit integer.

Copy(Array, Array, Int64) Copy(Array, Array, Int64) Copy(Array, Array, Int64) Copy(Array, Array, Int64)

Copia un intervalo de elementos de una matriz Array comenzando en el primer elemento y los pega en otra matriz Array comenzando en el primer elemento.Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. La longitud se especifica como un entero de 64 bits.The length is specified as a 64-bit integer.

Copy(Array, Int32, Array, Int32, Int32) Copy(Array, Int32, Array, Int32, Int32) Copy(Array, Int32, Array, Int32, Int32) Copy(Array, Int32, Array, Int32, Int32)

Copia un intervalo de elementos de un objeto Array a partir del índice de origen especificado y los pega en otro objeto Array a partir del índice de destino especificado.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. La longitud y los índices se especifican como enteros de 32 bits.The length and the indexes are specified as 32-bit integers.

Copy(Array, Int64, Array, Int64, Int64) Copy(Array, Int64, Array, Int64, Int64) Copy(Array, Int64, Array, Int64, Int64) Copy(Array, Int64, Array, Int64, Int64)

Copia un intervalo de elementos de un objeto Array a partir del índice de origen especificado y los pega en otro objeto Array a partir del índice de destino especificado.Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. La longitud y los índices se especifican como enteros de 64 bits.The length and the indexes are specified as 64-bit integers.

CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32)

Copia todos los elementos de la matriz unidimensional actual en la matriz unidimensional especificada, empezando en el índice especificado de la matriz de destino.Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. El índice se especifica como un entero de 32 bits.The index is specified as a 32-bit integer.

CopyTo(Array, Int64) CopyTo(Array, Int64) CopyTo(Array, Int64) CopyTo(Array, Int64)

Copia todos los elementos de la matriz unidimensional actual en la matriz unidimensional especificada, empezando en el índice especificado de la matriz de destino.Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. El índice se especifica como un entero de 64 bits.The index is specified as a 64-bit integer.

CreateInstance(Type, Int32) CreateInstance(Type, Int32) CreateInstance(Type, Int32) CreateInstance(Type, Int32)

Crea una matriz Array unidimensional de la longitud y el Type especificados, con una indización de base cero.Creates a one-dimensional Array of the specified Type and length, with zero-based indexing.

CreateInstance(Type, Int32, Int32) CreateInstance(Type, Int32, Int32) CreateInstance(Type, Int32, Int32) CreateInstance(Type, Int32, Int32)

Crea una matriz Array bidimensional de las longitudes de dimensión y el Type especificados, con una indización de base cero.Creates a two-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

CreateInstance(Type, Int32, Int32, Int32) CreateInstance(Type, Int32, Int32, Int32) CreateInstance(Type, Int32, Int32, Int32) CreateInstance(Type, Int32, Int32, Int32)

Crea una Array tridimensional de las longitudes de dimensión y el Type especificados, con una indización de base cero.Creates a three-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

CreateInstance(Type, Int32[]) CreateInstance(Type, Int32[]) CreateInstance(Type, Int32[]) CreateInstance(Type, Int32[])

Crea una Array multidimensional de las longitudes de dimensión y el tipo Type especificados, con una indización de base cero.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Las longitudes de dimensión se especifican en una matriz de enteros de 32 bits.The dimension lengths are specified in an array of 32-bit integers.

CreateInstance(Type, Int32[], Int32[]) CreateInstance(Type, Int32[], Int32[]) CreateInstance(Type, Int32[], Int32[]) CreateInstance(Type, Int32[], Int32[])

Crea una matriz Array multidimensional de las longitudes de dimensión y el tipo Type especificados, con los límites inferiores especificados.Creates a multidimensional Array of the specified Type and dimension lengths, with the specified lower bounds.

CreateInstance(Type, Int64[]) CreateInstance(Type, Int64[]) CreateInstance(Type, Int64[]) CreateInstance(Type, Int64[])

Crea una Array multidimensional de las longitudes de dimensión y el tipo Type especificados, con una indización de base cero.Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Las longitudes de dimensión se especifican en una matriz de enteros de 64 bits.The dimension lengths are specified in an array of 64-bit integers.

Empty<T>() Empty<T>() Empty<T>() Empty<T>()

Devuelve una matriz vacía.Returns an empty array.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
Exists<T>(T[], Predicate<T>) Exists<T>(T[], Predicate<T>) Exists<T>(T[], Predicate<T>) Exists<T>(T[], Predicate<T>)

Determina si la matriz especificada contiene elementos que coinciden con las condiciones definidas por el predicado especificado.Determines whether the specified array contains elements that match the conditions defined by the specified predicate.

Fill<T>(T[], T) Fill<T>(T[], T) Fill<T>(T[], T) Fill<T>(T[], T)
Fill<T>(T[], T, Int32, Int32) Fill<T>(T[], T, Int32, Int32) Fill<T>(T[], T, Int32, Int32) Fill<T>(T[], T, Int32, Int32)
Find<T>(T[], Predicate<T>) Find<T>(T[], Predicate<T>) Find<T>(T[], Predicate<T>) Find<T>(T[], Predicate<T>)

Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve la primera aparición en toda la matriz Array.Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire Array.

FindAll<T>(T[], Predicate<T>) FindAll<T>(T[], Predicate<T>) FindAll<T>(T[], Predicate<T>) FindAll<T>(T[], Predicate<T>)

Recupera todos los elementos que coinciden con las condiciones definidas por el predicado especificado.Retrieves all the elements that match the conditions defined by the specified predicate.

FindIndex<T>(T[], Int32, Int32, Predicate<T>) FindIndex<T>(T[], Int32, Int32, Predicate<T>) FindIndex<T>(T[], Int32, Int32, Predicate<T>) FindIndex<T>(T[], Int32, Int32, Predicate<T>)

Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición en el intervalo de elementos de la matriz Array que comienza en el índice especificado y contiene el número especificado de elementos.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the Array that starts at the specified index and contains the specified number of elements.

FindIndex<T>(T[], Int32, Predicate<T>) FindIndex<T>(T[], Int32, Predicate<T>) FindIndex<T>(T[], Int32, Predicate<T>) FindIndex<T>(T[], Int32, Predicate<T>)

Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición en el intervalo de elementos de la matriz Array que va desde el índice especificado hasta el último elemento.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the Array that extends from the specified index to the last element.

FindIndex<T>(T[], Predicate<T>) FindIndex<T>(T[], Predicate<T>) FindIndex<T>(T[], Predicate<T>) FindIndex<T>(T[], Predicate<T>)

Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición en toda la matriz Array.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire Array.

FindLast<T>(T[], Predicate<T>) FindLast<T>(T[], Predicate<T>) FindLast<T>(T[], Predicate<T>) FindLast<T>(T[], Predicate<T>)

Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve la última aparición en toda la matriz Array.Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire Array.

FindLastIndex<T>(T[], Int32, Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)

Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la última aparición en el intervalo de elementos de la matriz Array que contiene el número especificado de elementos y termina en el índice especificado.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the Array that contains the specified number of elements and ends at the specified index.

FindLastIndex<T>(T[], Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Predicate<T>) FindLastIndex<T>(T[], Int32, Predicate<T>)

Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la última aparición en el intervalo de elementos de la matriz Array que va desde el primer elemento hasta el índice especificado.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the Array that extends from the first element to the specified index.

FindLastIndex<T>(T[], Predicate<T>) FindLastIndex<T>(T[], Predicate<T>) FindLastIndex<T>(T[], Predicate<T>) FindLastIndex<T>(T[], Predicate<T>)

Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la última aparición en toda la matriz Array.Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire Array.

ForEach<T>(T[], Action<T>) ForEach<T>(T[], Action<T>) ForEach<T>(T[], Action<T>) ForEach<T>(T[], Action<T>)

Realiza la acción especificada en cada elemento de la matriz especificada.Performs the specified action on each element of the specified array.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Devuelve una interfaz IEnumerator para la interfaz Array.Returns an IEnumerator for the Array.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Inherited from Object)
GetLength(Int32) GetLength(Int32) GetLength(Int32) GetLength(Int32)

Obtiene un entero de 32 bits que representa el número de elementos de la dimensión especificada de Array.Gets a 32-bit integer that represents the number of elements in the specified dimension of the Array.

GetLongLength(Int32) GetLongLength(Int32) GetLongLength(Int32) GetLongLength(Int32)

Obtiene un entero de 64 bits que representa el número de elementos de la dimensión especificada de Array.Gets a 64-bit integer that represents the number of elements in the specified dimension of the Array.

GetLowerBound(Int32) GetLowerBound(Int32) GetLowerBound(Int32) GetLowerBound(Int32)

Obtiene el índice del primer elemento de la dimensión especificada en la matriz.Gets the index of the first element of the specified dimension in the array.

GetType() GetType() GetType() GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Inherited from Object)
GetUpperBound(Int32) GetUpperBound(Int32) GetUpperBound(Int32) GetUpperBound(Int32)

Obtiene el índice del último elemento de la dimensión especificada en la matriz.Gets the index of the last element of the specified dimension in the array.

GetValue(Int32) GetValue(Int32) GetValue(Int32) GetValue(Int32)

Obtiene el valor de la posición especificada de la matriz Array unidimensional.Gets the value at the specified position in the one-dimensional Array. El índice se especifica como un entero de 32 bits.The index is specified as a 32-bit integer.

GetValue(Int32, Int32) GetValue(Int32, Int32) GetValue(Int32, Int32) GetValue(Int32, Int32)

Obtiene el valor de la posición especificada de la matriz bidimensional Array.Gets the value at the specified position in the two-dimensional Array. Los índices se especifican como enteros de 32 bits.The indexes are specified as 32-bit integers.

GetValue(Int32, Int32, Int32) GetValue(Int32, Int32, Int32) GetValue(Int32, Int32, Int32) GetValue(Int32, Int32, Int32)

Obtiene el valor de la posición especificada de la matriz Array tridimensional.Gets the value at the specified position in the three-dimensional Array. Los índices se especifican como enteros de 32 bits.The indexes are specified as 32-bit integers.

GetValue(Int32[]) GetValue(Int32[]) GetValue(Int32[]) GetValue(Int32[])

Obtiene el valor de la posición especificada de Array multidimensional.Gets the value at the specified position in the multidimensional Array. Los índices se especifican en forma de una matriz de enteros de 32 bits.The indexes are specified as an array of 32-bit integers.

GetValue(Int64) GetValue(Int64) GetValue(Int64) GetValue(Int64)

Obtiene el valor de la posición especificada de la matriz Array unidimensional.Gets the value at the specified position in the one-dimensional Array. El índice se especifica como un entero de 64 bits.The index is specified as a 64-bit integer.

GetValue(Int64, Int64) GetValue(Int64, Int64) GetValue(Int64, Int64) GetValue(Int64, Int64)

Obtiene el valor de la posición especificada de la matriz bidimensional Array.Gets the value at the specified position in the two-dimensional Array. Los índices se especifican como enteros de 64 bits.The indexes are specified as 64-bit integers.

GetValue(Int64, Int64, Int64) GetValue(Int64, Int64, Int64) GetValue(Int64, Int64, Int64) GetValue(Int64, Int64, Int64)

Obtiene el valor de la posición especificada de la matriz Array tridimensional.Gets the value at the specified position in the three-dimensional Array. Los índices se especifican como enteros de 64 bits.The indexes are specified as 64-bit integers.

GetValue(Int64[]) GetValue(Int64[]) GetValue(Int64[]) GetValue(Int64[])

Obtiene el valor de la posición especificada de Array multidimensional.Gets the value at the specified position in the multidimensional Array. Los índices se especifican en forma de una matriz de enteros de 64 bits.The indexes are specified as an array of 64-bit integers.

IndexOf(Array, Object) IndexOf(Array, Object) IndexOf(Array, Object) IndexOf(Array, Object)

Busca el objeto especificado y devuelve el índice de su primera aparición en una matriz unidimensional.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32) IndexOf(Array, Object, Int32)

Busca el objeto especificado en un intervalo de elementos de la matriz unidimensional y devuelve el índice de su primera aparición.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. El intervalo se extiende desde un índice especificado hasta el final de la matriz.The range extends from a specified index to the end of the array.

IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32) IndexOf(Array, Object, Int32, Int32)

Busca el objeto especificado en un intervalo de elementos de una matriz unidimensional y devuelve el índice de su primera aparición.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of ifs first occurrence. El intervalo se extiende desde un índice especificado durante un número especificado de elementos.The range extends from a specified index for a specified number of elements.

IndexOf<T>(T[], T) IndexOf<T>(T[], T) IndexOf<T>(T[], T) IndexOf<T>(T[], T)

Busca el objeto especificado y devuelve el índice de su primera aparición en una matriz unidimensional.Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

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

Busca el objeto especificado en un intervalo de elementos de la matriz unidimensional y devuelve el índice de su primera aparición.Searches for the specified object in a range of elements of a one dimensional array, and returns the index of its first occurrence. El intervalo se extiende desde un índice especificado hasta el final de la matriz.The range extends from a specified index to the end of the array.

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

Busca el objeto especificado en un intervalo de elementos de la matriz unidimensional y devuelve el índice de su primera aparición.Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. El intervalo se extiende desde un índice especificado durante un número especificado de elementos.The range extends from a specified index for a specified number of elements.

Initialize() Initialize() Initialize() Initialize()

Inicializa todos los elementos de la matriz Array de tipo de valor llamando al constructor predeterminado del tipo de valor.Initializes every element of the value-type Array by calling the default constructor of the value type.

LastIndexOf(Array, Object) LastIndexOf(Array, Object) LastIndexOf(Array, Object) LastIndexOf(Array, Object)

Busca el objeto especificado y devuelve el índice de la última aparición en toda la matriz Array unidimensional.Searches for the specified object and returns the index of the last occurrence within the entire one-dimensional Array.

LastIndexOf(Array, Object, Int32) LastIndexOf(Array, Object, Int32) LastIndexOf(Array, Object, Int32) LastIndexOf(Array, Object, Int32)

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.Searches for the specified object and returns the index of the last occurrence within the range of elements in the one-dimensional Array that extends from the first element to the specified index.

LastIndexOf(Array, Object, Int32, Int32) LastIndexOf(Array, Object, Int32, Int32) LastIndexOf(Array, Object, Int32, Int32) LastIndexOf(Array, Object, Int32, Int32)

Busca el objeto especificado y devuelve el índice de la última aparición dentro del intervalo de elementos de la Array unidimensional que contiene el número especificado de elementos y termina en el índice especificado.Searches for the specified object and returns the index of the last occurrence within the range of elements in the one-dimensional Array that contains the specified number of elements and ends at the specified index.

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

Busca el objeto especificado y devuelve el índice de la última aparición de toda la Array.Searches for the specified object and returns the index of the last occurrence within the entire Array.

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

Busca el objeto especificado y devuelve el índice de la última aparición en el intervalo de elementos de la Array que se extiende desde el primer elemento hasta el índice especificado.Searches for the specified object and returns the index of the last occurrence within the range of elements in the Array that extends from the first element to the specified index.

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

Busca el objeto especificado y devuelve el índice de la última aparición en el intervalo de elementos de la Array que contiene el número de elementos especificado y termina en el índice especificado.Searches for the specified object and returns the index of the last occurrence within the range of elements in the Array that contains the specified number of elements and ends at the specified index.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Inherited from Object)
Resize<T>(T[], Int32) Resize<T>(T[], Int32) Resize<T>(T[], Int32) Resize<T>(T[], Int32)

Cambia el número de elementos de una matriz unidimensional al nuevo tamaño especificado.Changes the number of elements of a one-dimensional array to the specified new size.

Reverse(Array) Reverse(Array) Reverse(Array) Reverse(Array)

Invierte la secuencia de los elementos de toda la matriz Array unidimensional.Reverses the sequence of the elements in the entire one-dimensional Array.

Reverse(Array, Int32, Int32) Reverse(Array, Int32, Int32) Reverse(Array, Int32, Int32) Reverse(Array, Int32, Int32)

Invierte la secuencia de los elementos de un intervalo de elementos de la Array unidimensional.Reverses the sequence of the elements in a range of elements in the one-dimensional Array.

Reverse<T>(T[]) Reverse<T>(T[]) Reverse<T>(T[]) Reverse<T>(T[])
Reverse<T>(T[], Int32, Int32) Reverse<T>(T[], Int32, Int32) Reverse<T>(T[], Int32, Int32) Reverse<T>(T[], Int32, Int32)
SetValue(Object, Int32) SetValue(Object, Int32) SetValue(Object, Int32) SetValue(Object, Int32)

Establece un valor en el elemento situado en la posición especificada de una matriz Array unidimensional.Sets a value to the element at the specified position in the one-dimensional Array. El índice se especifica como un entero de 32 bits.The index is specified as a 32-bit integer.

SetValue(Object, Int32, Int32) SetValue(Object, Int32, Int32) SetValue(Object, Int32, Int32) SetValue(Object, Int32, Int32)

Establece un valor en el elemento situado en la posición especificada de la Array bidimensional.Sets a value to the element at the specified position in the two-dimensional Array. Los índices se especifican como enteros de 32 bits.The indexes are specified as 32-bit integers.

SetValue(Object, Int32, Int32, Int32) SetValue(Object, Int32, Int32, Int32) SetValue(Object, Int32, Int32, Int32) SetValue(Object, Int32, Int32, Int32)

Establece un valor en el elemento situado en la posición especificada de la Array tridimensional.Sets a value to the element at the specified position in the three-dimensional Array. Los índices se especifican como enteros de 32 bits.The indexes are specified as 32-bit integers.

SetValue(Object, Int32[]) SetValue(Object, Int32[]) SetValue(Object, Int32[]) SetValue(Object, Int32[])

Establece un valor en el elemento situado en la posición especificada de una matriz Array multidimensional.Sets a value to the element at the specified position in the multidimensional Array. Los índices se especifican en forma de una matriz de enteros de 32 bits.The indexes are specified as an array of 32-bit integers.

SetValue(Object, Int64) SetValue(Object, Int64) SetValue(Object, Int64) SetValue(Object, Int64)

Establece un valor en el elemento situado en la posición especificada de una matriz Array unidimensional.Sets a value to the element at the specified position in the one-dimensional Array. El índice se especifica como un entero de 64 bits.The index is specified as a 64-bit integer.

SetValue(Object, Int64, Int64) SetValue(Object, Int64, Int64) SetValue(Object, Int64, Int64) SetValue(Object, Int64, Int64)

Establece un valor en el elemento situado en la posición especificada de la Array bidimensional.Sets a value to the element at the specified position in the two-dimensional Array. Los índices se especifican como enteros de 64 bits.The indexes are specified as 64-bit integers.

SetValue(Object, Int64, Int64, Int64) SetValue(Object, Int64, Int64, Int64) SetValue(Object, Int64, Int64, Int64) SetValue(Object, Int64, Int64, Int64)

Establece un valor en el elemento situado en la posición especificada de la Array tridimensional.Sets a value to the element at the specified position in the three-dimensional Array. Los índices se especifican como enteros de 64 bits.The indexes are specified as 64-bit integers.

SetValue(Object, Int64[]) SetValue(Object, Int64[]) SetValue(Object, Int64[]) SetValue(Object, Int64[])

Establece un valor en el elemento situado en la posición especificada de una matriz Array multidimensional.Sets a value to the element at the specified position in the multidimensional Array. Los índices se especifican en forma de una matriz de enteros de 64 bits.The indexes are specified as an array of 64-bit integers.

Sort(Array) Sort(Array) Sort(Array) Sort(Array)

Ordena los elementos de toda una matriz Array unidimensional usando la implementación de IComparable de cada elemento de la matriz Array.Sorts the elements in an entire one-dimensional Array using the IComparable implementation of each element of the Array.

Sort(Array, Array) Sort(Array, Array) Sort(Array, Array) Sort(Array, Array)

Ordena un par de objetos Array unidimensionales (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera Array usando la implementación de IComparable de cada clave.Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

Sort(Array, Array, IComparer) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer) Sort(Array, Array, IComparer)

Ordena un par de objetos Array unidimensionales (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera Array usando la IComparer. especificada.Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32) Sort(Array, Array, Int32, Int32)

Ordena un intervalo de elementos en un par de objetos Array unidimensionales (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera matriz Array usando la implementación de IComparable de cada clave.Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer) Sort(Array, Array, Int32, Int32, IComparer)

Ordena un intervalo de elementos de un par de objetos Array unidimensionales (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera Array usando la interfaz IComparer especificada.Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

Sort(Array, IComparer) Sort(Array, IComparer) Sort(Array, IComparer) Sort(Array, IComparer)

Ordena los elementos de una matriz Array unidimensional usando la interfaz IComparer especificada.Sorts the elements in a one-dimensional Array using the specified IComparer.

Sort(Array, Int32, Int32) Sort(Array, Int32, Int32) Sort(Array, Int32, Int32) Sort(Array, Int32, Int32)

Ordena los elementos de un intervalo de elementos de una matriz Array unidimensional mediante el uso de la implementación de IComparable de cada elemento de la matriz Array.Sorts the elements in a range of elements in a one-dimensional Array using the IComparable implementation of each element of the Array.

Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer) Sort(Array, Int32, Int32, IComparer)

Ordena los elementos de un intervalo de elementos de una matriz Array unidimensional utilizando la interfaz IComparer especificada.Sorts the elements in a range of elements in a one-dimensional Array using the specified IComparer.

Sort<T>(T[]) Sort<T>(T[]) Sort<T>(T[]) Sort<T>(T[])

Ordena los elementos de toda una matriz Array usando la implementación de la interfaz genérica IComparable<T> de cada elemento de Array.Sorts the elements in an entire Array using the IComparable<T> generic interface implementation of each element of the Array.

Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>) Sort<T>(T[], Comparison<T>)

Ordena los elementos de una Array usando el Comparison<T> especificado.Sorts the elements in an Array using the specified Comparison<T>.

Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>) Sort<T>(T[], IComparer<T>)

Ordena los elementos de una Array usando la interfaz genérica IComparer<T> especificada.Sorts the elements in an Array using the specified IComparer<T> generic interface.

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

Ordena los elementos en un intervalo de elementos en una Array mediante la implementación de interfaz genérica IComparable<T> de cada elemento de la Array.Sorts the elements in a range of elements in an Array using the IComparable<T> generic interface implementation of each element of the Array.

Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>) Sort<T>(T[], Int32, Int32, IComparer<T>)

Ordena los elementos de un intervalo de elementos en un elemento Array mediante la interfaz genérica IComparer<T> especificada.Sorts the elements in a range of elements in an Array using the specified IComparer<T> generic interface.

Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[]) Sort<TKey,TValue>(TKey[], TValue[])

Ordena un par de objetos Array (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera Array usando la implementación de la interfaz genérica IComparable<T> de cada clave.Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)

Ordena un par de objetos Array (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera matriz Array usando la interfaz genérica IComparer<T> especificada.Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)

Ordena un intervalo de elementos en un par de objetos Array (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera matriz Array usando la implementación de la interfaz genérica IComparable<T> de cada clave.Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>) Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)

Ordena un intervalo de elementos de un par de objetos Array (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves de la primera matriz Array usando la interfaz genérica IComparer<T> especificada.Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

ToString() ToString() ToString() ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Inherited from Object)
TrueForAll<T>(T[], Predicate<T>) TrueForAll<T>(T[], Predicate<T>) TrueForAll<T>(T[], Predicate<T>) TrueForAll<T>(T[], Predicate<T>)

Determina si cada elemento de la matriz cumple las condiciones definidas por el predicado especificado.Determines whether every element in the array matches the conditions defined by the specified predicate.

Implementaciones de interfaz explícitas

ICollection.Count ICollection.Count ICollection.Count ICollection.Count

Obtiene el número de elementos incluidos en Array.Gets the number of elements contained in the Array.

ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized
ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot
IList.Add(Object) IList.Add(Object) IList.Add(Object) IList.Add(Object)

Cuando se llama a este método, siempre se produce una excepción NotSupportedException.Calling this method always throws a NotSupportedException exception.

IList.Clear() IList.Clear() IList.Clear() IList.Clear()

Quita todos los elementos de IList.Removes all items from the IList.

IList.Contains(Object) IList.Contains(Object) IList.Contains(Object) IList.Contains(Object)

Determina si un elemento se encuentra en IList.Determines whether an element is in the IList.

IList.IndexOf(Object) IList.IndexOf(Object) IList.IndexOf(Object) IList.IndexOf(Object)

Determina el índice de un elemento específico de IList.Determines the index of a specific item in the IList.

IList.Insert(Int32, Object) IList.Insert(Int32, Object) IList.Insert(Int32, Object) IList.Insert(Int32, Object)

Inserta un elemento en la interfaz IList, en el índice especificado.Inserts an item to the IList at the specified index.

IList.IsFixedSize IList.IsFixedSize IList.IsFixedSize IList.IsFixedSize
IList.IsReadOnly IList.IsReadOnly IList.IsReadOnly IList.IsReadOnly
IList.Item[Int32] IList.Item[Int32] IList.Item[Int32] IList.Item[Int32]

Obtiene o establece el elemento en el índice especificado.Gets or sets the element at the specified index.

IList.Remove(Object) IList.Remove(Object) IList.Remove(Object) IList.Remove(Object)

Quita la primera aparición de un objeto específico de la interfaz IList.Removes the first occurrence of a specific object from the IList.

IList.RemoveAt(Int32) IList.RemoveAt(Int32) IList.RemoveAt(Int32) IList.RemoveAt(Int32)

Quita el elemento de la interfaz IList que se encuentra en el índice especificado.Removes the IList item at the specified index.

IStructuralComparable.CompareTo(Object, IComparer) IStructuralComparable.CompareTo(Object, IComparer) IStructuralComparable.CompareTo(Object, IComparer) IStructuralComparable.CompareTo(Object, IComparer)

Determina si el objeto de colección actual precede o sigue a otro objeto en el criterio de ordenación, o aparece en la misma posición que él.Determines whether the current collection object precedes, occurs in the same position as, or follows another object in the sort order.

IStructuralEquatable.Equals(Object, IEqualityComparer) IStructuralEquatable.Equals(Object, IEqualityComparer) IStructuralEquatable.Equals(Object, IEqualityComparer) IStructuralEquatable.Equals(Object, IEqualityComparer)

Determina si un objeto especificado es igual a la instancia actual.Determines whether an object is equal to the current instance.

IStructuralEquatable.GetHashCode(IEqualityComparer) IStructuralEquatable.GetHashCode(IEqualityComparer) IStructuralEquatable.GetHashCode(IEqualityComparer) IStructuralEquatable.GetHashCode(IEqualityComparer)

Devuelve un código hash de la instancia actual.Returns a hash code for the current instance.

Extension Methods

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Convierte los elementos de IEnumerable en el tipo especificado.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtra los elementos de IEnumerable en función de un tipo especificado.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Habilita la paralelización de una consulta.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Convierte una interfaz IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

AsMemory<T>(T[]) AsMemory<T>(T[]) AsMemory<T>(T[]) AsMemory<T>(T[])
AsMemory<T>(T[], Int32) AsMemory<T>(T[], Int32) AsMemory<T>(T[], Int32) AsMemory<T>(T[], Int32)
AsMemory<T>(T[], Int32, Int32) AsMemory<T>(T[], Int32, Int32) AsMemory<T>(T[], Int32, Int32) AsMemory<T>(T[], Int32, Int32)
AsSpan<T>(T[]) AsSpan<T>(T[]) AsSpan<T>(T[]) AsSpan<T>(T[])
AsSpan<T>(T[], Int32) AsSpan<T>(T[], Int32) AsSpan<T>(T[], Int32) AsSpan<T>(T[], Int32)
AsSpan<T>(T[], Int32, Int32) AsSpan<T>(T[], Int32, Int32) AsSpan<T>(T[], Int32, Int32) AsSpan<T>(T[], Int32, Int32)
CopyTo<T>(T[], Memory<T>) CopyTo<T>(T[], Memory<T>) CopyTo<T>(T[], Memory<T>) CopyTo<T>(T[], Memory<T>)
CopyTo<T>(T[], Span<T>) CopyTo<T>(T[], Span<T>) CopyTo<T>(T[], Span<T>) CopyTo<T>(T[], Span<T>)

Se aplica a

Seguridad para subprocesos

Estáticos públicos (Shared en Visual Basic) los miembros de este tipo son seguros para subprocesos.Public static (Shared in Visual Basic) members of this type are thread safe. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.Any instance members are not guaranteed to be thread safe.

Esta implementación no proporciona un sincronizada contenedor (es seguro para subprocesos) para un Array; sin embargo, según las clases de .NET Framework Array proporcionar su propia versión sincronizada de la colección utilizando el SyncRoot propiedad.This implementation does not provide a synchronized (thread safe) wrapper for an Array; however, .NET Framework classes based on Array provide their own synchronized version of the collection using the SyncRoot property.

Enumerar una colección no es intrínsecamente un procedimiento seguro para subprocesos.Enumerating through a collection is intrinsically not a thread-safe procedure. Incluso cuando una colección está sincronizada, otros subprocesos todavía pueden modificarla, lo que hace que el enumerador produzca una excepción.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. Con el fin de garantizar la seguridad para la ejecución de subprocesos durante la enumeración, se puede bloquear la colección durante toda la enumeración o detectar las excepciones resultantes de los cambios realizados por otros subprocesos.To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.

Consulte también: