Array Clase

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Source:

Array.cs

Proporciona métodos para crear, manipular, buscar y ordenar matrices, lo que actúa como clase base para todas las matrices de Common Language Runtime.

public ref class Array abstract : ICloneable, System::Collections::IList, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable

public abstract class Array : ICloneable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable

type Array = class
    interface ICollection
    interface IEnumerable
    interface IList
    interface IStructuralComparable
    interface IStructuralEquatable
    interface ICloneable

Public MustInherit Class Array
Implements ICloneable, IList, IStructuralComparable, IStructuralEquatable

Herencia

Object

Array

Implementaciones

ICollection IEnumerable IList IStructuralComparable IStructuralEquatable ICloneable

Ejemplos

En el ejemplo de código siguiente se muestra cómo Array.Copy copia los elementos entre una matriz de tipo entero y una matriz de tipo 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
*/

open System

let printValues myArr =
    for i in myArr do
        printf $"\t{i}"
    printfn ""

// Creates and initializes a new integer array and a new Object array.
let myIntArray = [| 1..5 |]
let myObjArray = [| 26..30 |]

// Prints the initial values of both arrays.
printfn "Initially,"
printf "integer array:"
printValues myIntArray
printfn "Object array: "
printValues myObjArray

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

// Prints the values of the modified arrays.
printfn "\nAfter copying the first two elements of the integer array to the Object array,"
printf "integer array:"
printValues myIntArray
printf"Object array: "
printValues myObjArray

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

// Prints the values of the modified arrays.
printfn $"\nAfter copying the last two elements of the Object array to the integer array,"
printf "integer array:"
printValues myIntArray
printf "Object array: "
printValues myObjArray


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

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 se muestran sus propiedades y sus elementos.

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

open System

let printValues (myArray: Array) =
    let mutable i = 0
    let cols = myArray.GetLength(myArray.Rank - 1)
    for item in myArray do
        if i < cols then
            i <- i + 1
        else
            printfn ""
            i <- 1;
        printf $"\t{item}"
    printfn ""

// Creates and initializes a new three-dimensional Array of type int.
let myArr = Array.CreateInstance(typeof<int>, 2, 3, 4)
for i = myArr.GetLowerBound 0 to myArr.GetUpperBound 0 do
    for j = myArr.GetLowerBound 1 to myArr.GetUpperBound 1 do
        for k = myArr.GetLowerBound 2 to myArr.GetUpperBound 2 do
            myArr.SetValue(i * 100 + j * 10 + k, i, j, k)

// Displays the properties of the Array.
printfn $"The Array has {myArr.Rank} dimension(s) and a total of {myArr.Length} elements."
printfn $"\tLength\tLower\tUpper"

for i = 0 to myArr.Rank - 1 do
    printf $"{i}:\t{myArr.GetLength i}"
    printfn $"\t{myArr.GetLowerBound i}\t{myArr.GetUpperBound i}"

// Displays the contents of the Array.
printfn "The Array contains the following values:"
printValues myArr

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

// Creates and initializes a new three-dimensional Array of type int.
Array myArr = Array.CreateInstance(typeof(int), 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);

void PrintValues(Array myArray)
{
    System.Collections.IEnumerator myEnumerator = myArray.GetEnumerator();
    int i = 0;
    int cols = myArray.GetLength(myArray.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

La clase Array no forma parte de los espacios de nombres System.Collections. Sin embargo, todavía se considera una colección porque se basa en la interfaz IList.

La clase Array es la clase base para las implementaciones de lenguaje que admiten matrices. Sin embargo, solo el sistema y los compiladores pueden derivar explícitamente de la clase Array. Los usuarios deben emplear las construcciones de matriz proporcionadas por el lenguaje .

Un elemento es un valor de un Array. La longitud de un Array es el número total de elementos que puede contener. El límite inferior de un Array es el índice de su primer elemento. Un Array puede tener cualquier límite inferior, pero tiene un límite inferior de cero de forma predeterminada. Se puede definir un límite inferior diferente al crear una instancia de la clase Array mediante CreateInstance. Un Array multidimensional puede tener límites diferentes para cada dimensión. Una matriz puede tener un máximo de 32 dimensiones.

A diferencia de las clases de los espacios de nombres System.Collections, Array tiene una capacidad fija. Para aumentar la capacidad, debe crear un nuevo objeto Array con la capacidad necesaria, copiar los elementos del objeto Array antiguo al nuevo y eliminar el antiguo Array.

El tamaño de la matriz se limita a un total de 4 mil millones de elementos y a un índice máximo de 0X7FEFFFFF en cualquier dimensión determinada (0X7FFFFFC7 para matrices de bytes y matrices de estructuras de un solo byte).

solo .NET Framework: De forma predeterminada, el tamaño máximo de un Array es de 2 gigabytes (GB). En un entorno de 64 bits, puede evitar la restricción de tamaño estableciendo el atributo enabled del gcAllowVeryLargeObjects elemento de configuración en true en el entorno en tiempo de ejecución.

Las matrices unidimensionales implementan las interfaces genéricas 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> genéricas. Las implementaciones se proporcionan a matrices en tiempo de ejecución y, como resultado, las interfaces genéricas no aparecen en la sintaxis de declaración de la clase Array. Además, no hay temas de referencia para los miembros de la interfaz a los que solo se puede acceder mediante la conversión de una matriz al tipo de interfaz genérico (implementaciones de interfaz explícitas). Lo clave que debe tener en cuenta al convertir una matriz en una de estas interfaces es que los miembros que agregan, insertan o quitan elementos inician NotSupportedException.

Type objetos proporcionan información sobre las declaraciones de tipo de matriz. Array objetos con el mismo tipo de matriz comparten el mismo objeto Type.

Type.IsArray y Type.GetElementType podrían no devolver los resultados esperados con Array porque si una matriz se convierte en el tipo Array, el resultado es un objeto, no una matriz. Es decir, typeof(System.Array).IsArray devuelve falsey typeof(System.Array).GetElementType devuelve null.

El método Array.Copy copia elementos no solo entre matrices del mismo tipo, sino también entre matrices estándar de diferentes tipos; controla la conversión de tipos automáticamente.

Algunos métodos, como CreateInstance, Copy, CopyTo, GetValuey SetValue, proporcionan sobrecargas que aceptan enteros de 64 bits como parámetros para dar cabida a matrices de gran capacidad. LongLength y GetLongLength devuelven enteros de 64 bits que indican la longitud de la matriz.

No se garantiza que el Array se ordene. Debe ordenar el Array antes de realizar operaciones (como BinarySearch) que requieren que se ordene el Array.

No se admite el uso de un objeto Array de punteros en código nativo y generará una NotSupportedException para varios métodos.

Propiedades

IsFixedSize	Obtiene un valor que indica si el Array tiene un tamaño fijo.
IsReadOnly	Obtiene un valor que indica si el Array es de solo lectura.
IsSynchronized	Obtiene un valor que indica si el acceso a la Array está sincronizado (seguro para subprocesos).
Length	Obtiene el número total de elementos de todas las dimensiones del Array.
LongLength	Obtiene un entero de 64 bits que representa el número total de elementos de todas las dimensiones de la Array.
MaxLength	Obtiene el número máximo de elementos que se pueden contener en una matriz.
Rank	Obtiene el rango (número de dimensiones) del Array. Por ejemplo, una matriz unidimensional devuelve 1, una matriz bidimensional devuelve 2, etc.
SyncRoot	Obtiene un objeto que se puede usar para sincronizar el acceso a la Array.

Métodos

AsReadOnly<T>(T[])	Devuelve un contenedor de solo lectura para la matriz especificada.
BinarySearch(Array, Int32, Int32, Object)	Busca en un valor un intervalo de elementos de una matriz ordenada unidimensional, utilizando la interfaz IComparable implementada por cada elemento de la matriz y por el valor especificado.
BinarySearch(Array, Int32, Int32, Object, IComparer)	Busca en un valor un intervalo de elementos de una matriz ordenada unidimensional mediante la interfaz IComparer especificada.
BinarySearch(Array, Object)	Busca una matriz ordenada unidimensional completa para un elemento específico, utilizando la interfaz IComparable implementada por cada elemento de la matriz y por el objeto especificado.
BinarySearch(Array, Object, IComparer)	Busca en una matriz ordenada unidimensional completa un valor mediante la interfaz IComparer especificada.
BinarySearch<T>(T[], Int32, Int32, T)	Busca en un valor un intervalo de elementos de una matriz ordenada unidimensional, utilizando la interfaz genérica IComparable<T> implementada por cada elemento del Array y por el valor especificado.
BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)	Busca en un valor un intervalo de elementos de una matriz ordenada unidimensional mediante la interfaz genérica IComparer<T> especificada.
BinarySearch<T>(T[], T)	Busca en una matriz ordenada unidimensional completa un elemento específico, utilizando la interfaz genérica IComparable<T> implementada por cada elemento de la Array y por el objeto especificado.
BinarySearch<T>(T[], T, IComparer<T>)	Busca en una matriz ordenada unidimensional completa un valor mediante la interfaz genérica IComparer<T> especificada.
Clear(Array)	Borra el contenido de una matriz.
Clear(Array, Int32, Int32)	Establece un intervalo de elementos de una matriz en el valor predeterminado de cada tipo de elemento.
Clone()	Crea una copia superficial del Array.
ConstrainedCopy(Array, Int32, Array, Int32, Int32)	Copia un intervalo de elementos de un Array a partir del índice de origen especificado y los pega a otro Array a partir del índice de destino especificado. Garantiza que todos los cambios se deshacen si la copia no se realiza correctamente.
ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>)	Convierte una matriz de un tipo en una matriz de otro tipo.
Copy(Array, Array, Int32)	Copia un intervalo de elementos de un Array comenzando en el primer elemento y los pega en otro Array comenzando en el primer elemento. La longitud se especifica como un entero de 32 bits.
Copy(Array, Array, Int64)	Copia un intervalo de elementos de un Array comenzando en el primer elemento y los pega en otro Array comenzando en el primer elemento. La longitud se especifica como un entero de 64 bits.
Copy(Array, Int32, Array, Int32, Int32)	Copia un intervalo de elementos de un Array a partir del índice de origen especificado y los pega a otro Array a partir del índice de destino especificado. La longitud y los índices se especifican como enteros de 32 bits.
Copy(Array, Int64, Array, Int64, Int64)	Copia un intervalo de elementos de un Array a partir del índice de origen especificado y los pega a otro Array a partir del índice de destino especificado. La longitud y los índices se especifican como enteros de 64 bits.
CopyTo(Array, Int32)	Copia todos los elementos de la matriz unidimensional actual en la matriz unidimensional especificada a partir del índice de matriz de destino especificado. El índice se especifica como un entero de 32 bits.
CopyTo(Array, Int64)	Copia todos los elementos de la matriz unidimensional actual en la matriz unidimensional especificada a partir del índice de matriz de destino especificado. El índice se especifica como un entero de 64 bits.
CreateInstance(Type, Int32)	Crea una Array unidimensional del Type y la longitud especificados, con indexación de base cero.
CreateInstance(Type, Int32, Int32)	Crea un Array bidimensional de las longitudes de dimensión y Type especificadas, con indexación de base cero.
CreateInstance(Type, Int32, Int32, Int32)	Crea una Array tridimensional de las longitudes de dimensión y Type especificadas, con indexación de base cero.
CreateInstance(Type, Int32[])	Crea un Array multidimensional de las longitudes de dimensión y Type especificadas, con indexación de base cero. Las longitudes de dimensión se especifican en una matriz de enteros de 32 bits.
CreateInstance(Type, Int32[], Int32[])	Crea un Array multidimensional de las longitudes de dimensión y Type especificadas, con los límites inferiores especificados.
CreateInstance(Type, Int64[])	Crea un Array multidimensional de las longitudes de dimensión y Type especificadas, con indexación de base cero. Las longitudes de dimensión se especifican en una matriz de enteros de 64 bits.
Empty<T>()	Devuelve una matriz vacía.
Equals(Object)	Determina si el objeto especificado es igual al objeto actual. (Heredado de Object)
Exists<T>(T[], Predicate<T>)	Determina si la matriz especificada contiene elementos que coinciden con las condiciones definidas por el predicado especificado.
Fill<T>(T[], T)	Asigna el value especificado de tipo T a cada elemento del arrayespecificado.
Fill<T>(T[], T, Int32, Int32)	Asigna el value especificado de tipo T a los elementos del array especificado que se encuentran dentro del intervalo de startIndex (inclusive) y el siguiente número de índices de count.
Find<T>(T[], Predicate<T>)	Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve la primera aparición dentro de toda la Array.
FindAll<T>(T[], Predicate<T>)	Recupera todos los elementos que coinciden con las condiciones definidas por el predicado especificado.
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 dentro del intervalo de elementos del Array que comienza en el índice especificado y contiene el número especificado de elementos.
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 dentro del intervalo de elementos del Array que se extiende del índice especificado al último elemento.
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 dentro de toda la Array.
FindLast<T>(T[], Predicate<T>)	Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve la última aparición dentro de toda la Array.
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 dentro del intervalo de elementos de la Array que contiene el número especificado de elementos y termina en el índice especificado.
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 dentro del intervalo de elementos del Array que se extiende desde el primer elemento al índice especificado.
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 Array.
ForEach<T>(T[], Action<T>)	Realiza la acción especificada en cada elemento de la matriz especificada.
GetEnumerator()	Devuelve un IEnumerator para el Array.
GetHashCode()	Actúa como función hash predeterminada. (Heredado de Object)
GetLength(Int32)	Obtiene un entero de 32 bits que representa el número de elementos de la dimensión especificada del Array.
GetLongLength(Int32)	Obtiene un entero de 64 bits que representa el número de elementos de la dimensión especificada del Array.
GetLowerBound(Int32)	Obtiene el índice del primer elemento de la dimensión especificada en la matriz.
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
GetUpperBound(Int32)	Obtiene el índice del último elemento de la dimensión especificada en la matriz.
GetValue(Int32)	Obtiene el valor en la posición especificada en el Arrayunidimensional . El índice se especifica como un entero de 32 bits.
GetValue(Int32, Int32)	Obtiene el valor en la posición especificada en el Arraybidimensional . Los índices se especifican como enteros de 32 bits.
GetValue(Int32, Int32, Int32)	Obtiene el valor en la posición especificada en el Arraytridimensional . Los índices se especifican como enteros de 32 bits.
GetValue(Int32[])	Obtiene el valor en la posición especificada del Arraymultidimensional. Los índices se especifican como una matriz de enteros de 32 bits.
GetValue(Int64)	Obtiene el valor en la posición especificada en el Arrayunidimensional . El índice se especifica como un entero de 64 bits.
GetValue(Int64, Int64)	Obtiene el valor en la posición especificada en el Arraybidimensional . Los índices se especifican como enteros de 64 bits.
GetValue(Int64, Int64, Int64)	Obtiene el valor en la posición especificada en el Arraytridimensional . Los índices se especifican como enteros de 64 bits.
GetValue(Int64[])	Obtiene el valor en la posición especificada del Arraymultidimensional. Los índices se especifican como una matriz de enteros de 64 bits.
IndexOf(Array, Object)	Busca el objeto especificado y devuelve el índice de su primera aparición en una matriz unidimensional.
IndexOf(Array, Object, Int32)	Busca el objeto especificado en un intervalo de elementos de una matriz unidimensional y devuelve el índice de su primera aparición. El intervalo se extiende desde un índice especificado hasta el final de la matriz.
IndexOf(Array, Object, Int32, Int32)	Busca el objeto especificado en un intervalo de elementos de una matriz unidimensional y devuelve el índice de ifs first occurrence. El intervalo se extiende desde un índice especificado para un número especificado de elementos.
IndexOf<T>(T[], T)	Busca el objeto especificado y devuelve el índice de su primera aparición en una matriz unidimensional.
IndexOf<T>(T[], T, Int32)	Busca el objeto especificado en un intervalo de elementos de una matriz unidimensional y devuelve el índice de su primera aparición. El intervalo se extiende desde un índice especificado hasta el final de la matriz.
IndexOf<T>(T[], T, Int32, Int32)	Busca el objeto especificado en un intervalo de elementos de una matriz unidimensional y devuelve el índice de su primera aparición. El intervalo se extiende desde un índice especificado para un número especificado de elementos.
Initialize()	Inicializa todos los elementos del tipo de valor Array llamando al constructor sin parámetros del tipo de valor.
LastIndexOf(Array, Object)	Busca el objeto especificado y devuelve el índice de la última aparición en toda la Arrayunidimensional completa.
LastIndexOf(Array, Object, Int32)	Busca el objeto especificado y devuelve el índice de la última aparición dentro del intervalo de elementos de la Array unidimensional que se extiende desde el primer elemento hasta el índice especificado.
LastIndexOf(Array, Object, Int32, Int32)	Busca el objeto especificado y devuelve el índice de la última aparición dentro del intervalo de elementos del Array unidimensional que contiene el número especificado de elementos y termina en el índice especificado.
LastIndexOf<T>(T[], T)	Busca el objeto especificado y devuelve el índice de la última aparición en toda la Array.
LastIndexOf<T>(T[], T, Int32)	Busca el objeto especificado y devuelve el índice de la última aparición dentro del intervalo de elementos del Array que se extiende desde el primer elemento al índice especificado.
LastIndexOf<T>(T[], T, Int32, Int32)	Busca el objeto especificado y devuelve el índice de la última aparición dentro del intervalo de elementos del Array que contiene el número especificado de elementos y termina en el índice especificado.
MemberwiseClone()	Crea una copia superficial del Objectactual. (Heredado de Object)
Resize<T>(T[], Int32)	Cambia el número de elementos de una matriz unidimensional al nuevo tamaño especificado.
Reverse(Array)	Invierte la secuencia de los elementos en toda la Arrayunidimensional.
Reverse(Array, Int32, Int32)	Invierte la secuencia de un subconjunto de los elementos de la Arrayunidimensional .
Reverse<T>(T[])	Invierte la secuencia de los elementos de la matriz genérica unidimensional.
Reverse<T>(T[], Int32, Int32)	Invierte la secuencia de un subconjunto de los elementos de la matriz genérica unidimensional.
SetValue(Object, Int32)	Establece un valor en el elemento situado en la posición especificada en el Arrayunidimensional . El índice se especifica como un entero de 32 bits.
SetValue(Object, Int32, Int32)	Establece un valor en el elemento situado en la posición especificada en el Arraybidimensional . Los índices se especifican como enteros de 32 bits.
SetValue(Object, Int32, Int32, Int32)	Establece un valor en el elemento situado en la posición especificada en el Arraytridimensional . Los índices se especifican como enteros de 32 bits.
SetValue(Object, Int32[])	Establece un valor en el elemento situado en la posición especificada del Arraymultidimensional. Los índices se especifican como una matriz de enteros de 32 bits.
SetValue(Object, Int64)	Establece un valor en el elemento situado en la posición especificada en el Arrayunidimensional . El índice se especifica como un entero de 64 bits.
SetValue(Object, Int64, Int64)	Establece un valor en el elemento situado en la posición especificada en el Arraybidimensional . Los índices se especifican como enteros de 64 bits.
SetValue(Object, Int64, Int64, Int64)	Establece un valor en el elemento situado en la posición especificada en el Arraytridimensional . Los índices se especifican como enteros de 64 bits.
SetValue(Object, Int64[])	Establece un valor en el elemento situado en la posición especificada del Arraymultidimensional. Los índices se especifican como una matriz de enteros de 64 bits.
Sort(Array)	Ordena los elementos de una Array unidimensional completa mediante la implementación IComparable de cada elemento de la 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 mediante la implementación de IComparable de cada clave.
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 mediante el IComparerespecificado.
Sort(Array, Array, Int32, Int32)	Ordena un intervalo de elementos en un par de objetos de Array unidimensionales (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves del primer Array mediante la implementación IComparable de cada clave.
Sort(Array, Array, Int32, Int32, IComparer)	Ordena un intervalo de elementos en un par de objetos de Array unidimensionales (uno contiene las claves y el otro contiene los elementos correspondientes) en función de las claves del primer Array mediante el IComparerespecificado.
Sort(Array, IComparer)	Ordena los elementos de un Array unidimensional mediante el IComparerespecificado.
Sort(Array, Int32, Int32)	Ordena los elementos de un rango de elementos de un Array unidimensional mediante la implementación IComparable de cada elemento de la Array.
Sort(Array, Int32, Int32, IComparer)	Ordena los elementos de un rango de elementos de un Array unidimensional mediante el IComparerespecificado.
Sort<T>(T[])	Ordena los elementos de un Array completo mediante la implementación de interfaz genérica IComparable<T> de cada elemento del Array.
Sort<T>(T[], Comparison<T>)	Ordena los elementos de un Array mediante el Comparison<T>especificado.
Sort<T>(T[], IComparer<T>)	Ordena los elementos de un Array mediante la interfaz genérica IComparer<T> especificada.
Sort<T>(T[], Int32, Int32)	Ordena los elementos de un intervalo de elementos de un Array mediante la implementación de interfaz genérica de IComparable<T> de cada elemento de la Array.
Sort<T>(T[], Int32, Int32, IComparer<T>)	Ordena los elementos de un intervalo de elementos de un Array mediante la interfaz genérica IComparer<T> especificada.
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 del primer Array mediante la implementación de interfaz genérica de IComparable<T> de cada clave.
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 del primer Array mediante la interfaz genérica IComparer<T> especificada.
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 del primer Array mediante la implementación de interfaz genérica de IComparable<T> de cada clave.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)	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 del primer Array mediante la interfaz genérica IComparer<T> especificada.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
TrueForAll<T>(T[], Predicate<T>)	Determina si cada elemento de la matriz coincide con las condiciones definidas por el predicado especificado.

Implementaciones de interfaz explícitas

ICollection.Count	Obtiene el número de elementos contenidos en el Array.
IList.Add(Object)	Al llamar a este método siempre se produce una excepción NotSupportedException.
IList.Clear()	Quita todos los elementos de la IList.
IList.Contains(Object)	Determina si un elemento está en el IList.
IList.IndexOf(Object)	Determina el índice de un elemento específico del IList.
IList.Insert(Int32, Object)	Inserta un elemento en el IList en el índice especificado.
IList.Item[Int32]	Obtiene o establece el elemento en el índice especificado.
IList.Remove(Object)	Quita la primera aparición de un objeto específico de la IList.
IList.RemoveAt(Int32)	Quita el elemento IList en el índice especificado.
IStructuralComparable.CompareTo(Object, IComparer)	Determina si el objeto de colección actual precede, se produce en la misma posición que o sigue a otro objeto en el criterio de ordenación.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Determina si un objeto es igual a la instancia actual.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Devuelve un código hash para la instancia actual.

Métodos de extensión

Cast<TResult>(IEnumerable)	Convierte los elementos de un IEnumerable al tipo especificado.
OfType<TResult>(IEnumerable)	Filtra los elementos de un IEnumerable en función de un tipo especificado.
AsParallel(IEnumerable)	Habilita la paralelización de una consulta.
AsQueryable(IEnumerable)	Convierte un IEnumerable en un IQueryable.

Seguridad para subprocesos

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Esta implementación no proporciona un contenedor sincronizado (seguro para subprocesos) para un Array; sin embargo, las clases de .NET basadas en Array proporcionan su propia versión sincronizada de la colección mediante la propiedad SyncRoot.

La enumeración a través de una colección no es intrínsecamente un procedimiento seguro para subprocesos. Incluso cuando se sincroniza una colección, otros subprocesos todavía pueden modificar la colección, lo que hace que el enumerador inicie una excepción. Para garantizar la seguridad de los subprocesos durante la enumeración, puede bloquear la colección durante toda la enumeración o detectar las excepciones resultantes de los cambios realizados por otros subprocesos.

Consulte también

• Object
• Type
• realizar operaciones de cadena Culture-Insensitive en matrices
• matrices (Guía de programación de C#)
• Matrices en de F#
• Matrices en Visual Basic