Array Classe

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Origem:

Array.cs

Fornece métodos para criar, manipular, pesquisar e classificar matrizes, servindo assim como a classe base para todas as matrizes no 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

Herança

Object

Array

Implementações

ICollection IEnumerable IList IStructuralComparable IStructuralEquatable ICloneable

Exemplos

O exemplo de código a seguir mostra como Array.Copy copia elementos entre uma matriz de inteiros de tipo e uma 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

O exemplo de código a seguir cria e inicializa um Array e exibe suas propriedades e seus 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

Comentários

A classe Array não faz parte dos namespaces System.Collections. No entanto, ela ainda é considerada uma coleção porque se baseia na interface IList.

A classe Array é a classe base para implementações de idioma que dão suporte a matrizes. No entanto, somente o sistema e os compiladores podem derivar explicitamente da classe Array. Os usuários devem empregar os constructos de matriz fornecidos pelo idioma.

Um elemento é um valor em um Array. O comprimento de um Array é o número total de elementos que ele pode conter. O limite inferior de um Array é o índice de seu primeiro elemento. Um Array pode ter qualquer limite inferior, mas tem um limite inferior de zero por padrão. Um limite inferior diferente pode ser definido ao criar uma instância da classe Array usando CreateInstance. Uma Array multidimensional pode ter limites diferentes para cada dimensão. Uma matriz pode ter no máximo 32 dimensões.

Ao contrário das classes nos namespaces System.Collections, Array tem uma capacidade fixa. Para aumentar a capacidade, você deve criar um novo objeto Array com a capacidade necessária, copiar os elementos do objeto Array antigo para o novo e excluir o Arrayantigo.

O tamanho da matriz é limitado a um total de 4 bilhões de elementos e a um índice máximo de 0X7FEFFFFF em qualquer dimensão (0X7FFFFFC7 para matrizes de bytes e matrizes de estruturas de bytes únicos).

somente .NET Framework: Por padrão, o tamanho máximo de um Array é de 2 gigabytes (GB). Em um ambiente de 64 bits, você pode evitar a restrição de tamanho definindo o atributo enabled do elemento de configuração gcAllowVeryLargeObjects para true no ambiente de tempo de execução.

Matrizes unidimensionais implementam as interfaces genéricas System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyList<T> e System.Collections.Generic.IReadOnlyCollection<T>. As implementações são fornecidas a matrizes em tempo de execução e, como resultado, as interfaces genéricas não aparecem na sintaxe de declaração da classe Array. Além disso, não há tópicos de referência para membros de interface acessíveis apenas por meio da conversão de uma matriz para o tipo de interface genérica (implementações de interface explícitas). O importante a ser ciente quando você converte uma matriz em uma dessas interfaces é que os membros que adicionam, inserem ou removem elementos lançam NotSupportedException.

Type objetos fornecem informações sobre declarações de tipo de matriz. Array objetos com o mesmo tipo de matriz compartilham o mesmo objeto Type.

Type.IsArray e Type.GetElementType podem não retornar os resultados esperados com Array porque se uma matriz for convertida no tipo Array, o resultado será um objeto, não uma matriz. Ou seja, typeof(System.Array).IsArray retorna falsee typeof(System.Array).GetElementType retorna null.

O método Array.Copy copia elementos não apenas entre matrizes do mesmo tipo, mas também entre matrizes padrão de tipos diferentes; ele manipula a conversão de tipos automaticamente.

Alguns métodos, como CreateInstance, Copy, CopyTo, GetValuee SetValue, fornecem sobrecargas que aceitam inteiros de 64 bits como parâmetros para acomodar grandes matrizes de capacidade. LongLength e GetLongLength retornam inteiros de 64 bits indicando o comprimento da matriz.

O Array não tem garantia de ser classificado. Você deve classificar a Array antes de executar operações (como BinarySearch) que exigem que a Array seja classificada.

Não há suporte para o uso de um objeto Array de ponteiros no código nativo e gerará um NotSupportedException para vários métodos.

Propriedades

IsFixedSize	Obtém um valor que indica se o Array tem um tamanho fixo.
IsReadOnly	Obtém um valor que indica se o Array é somente leitura.
IsSynchronized	Obtém um valor que indica se o acesso ao Array é sincronizado (thread safe).
Length	Obtém o número total de elementos em todas as dimensões do Array.
LongLength	Obtém um inteiro de 64 bits que representa o número total de elementos em todas as dimensões do Array.
MaxLength	Obtém o número máximo de elementos que podem estar contidos em uma matriz.
Rank	Obtém a classificação (número de dimensões) do Array. Por exemplo, uma matriz unidimensional retorna 1, uma matriz bidimensional retorna 2 e assim por diante.
SyncRoot	Obtém um objeto que pode ser usado para sincronizar o acesso ao Array.

Métodos

AsReadOnly<T>(T[])	Retorna um wrapper somente leitura para a matriz especificada.
BinarySearch(Array, Int32, Int32, Object)	Pesquisa um intervalo de elementos em uma matriz classificada unidimensional para um valor, usando a interface IComparable implementada por cada elemento da matriz e pelo valor especificado.
BinarySearch(Array, Int32, Int32, Object, IComparer)	Pesquisa um intervalo de elementos em uma matriz classificada unidimensional para obter um valor, usando a interface IComparer especificada.
BinarySearch(Array, Object)	Pesquisa uma matriz classificada unidimensional inteira para um elemento específico, usando a interface IComparable implementada por cada elemento da matriz e pelo objeto especificado.
BinarySearch(Array, Object, IComparer)	Pesquisa uma matriz classificada unidimensional inteira para obter um valor usando a interface de IComparer especificada.
BinarySearch<T>(T[], Int32, Int32, T)	Pesquisa um intervalo de elementos em uma matriz classificada unidimensional para um valor, usando o IComparable<T> interface genérica implementada por cada elemento do Array e pelo valor especificado.
BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)	Pesquisa um intervalo de elementos em uma matriz classificada unidimensional para obter um valor, usando a interface genérica IComparer<T> especificada.
BinarySearch<T>(T[], T)	Pesquisa uma matriz classificada unidimensional inteira para um elemento específico, usando o IComparable<T> interface genérica implementada por cada elemento do Array e pelo objeto especificado.
BinarySearch<T>(T[], T, IComparer<T>)	Pesquisa uma matriz classificada unidimensional inteira para obter um valor usando a interface genérica IComparer<T> especificada.
Clear(Array)	Limpa o conteúdo de uma matriz.
Clear(Array, Int32, Int32)	Define um intervalo de elementos em uma matriz para o valor padrão de cada tipo de elemento.
Clone()	Cria uma cópia superficial do Array.
ConstrainedCopy(Array, Int32, Array, Int32, Int32)	Copia um intervalo de elementos de um Array começando no índice de origem especificado e cola-os em outro Array começando no índice de destino especificado. Garante que todas as alterações serão desfeitas se a cópia não tiver êxito completamente.
ConvertAll<TInput,TOutput>(TInput[], Converter<TInput,TOutput>)	Converte uma matriz de um tipo em uma matriz de outro tipo.
Copy(Array, Array, Int32)	Copia um intervalo de elementos de um Array começando no primeiro elemento e cola-os em outro Array começando no primeiro elemento. O comprimento é especificado como um inteiro de 32 bits.
Copy(Array, Array, Int64)	Copia um intervalo de elementos de um Array começando no primeiro elemento e cola-os em outro Array começando no primeiro elemento. O comprimento é especificado como um inteiro de 64 bits.
Copy(Array, Int32, Array, Int32, Int32)	Copia um intervalo de elementos de um Array começando no índice de origem especificado e cola-os em outro Array começando no índice de destino especificado. O comprimento e os índices são especificados como inteiros de 32 bits.
Copy(Array, Int64, Array, Int64, Int64)	Copia um intervalo de elementos de um Array começando no índice de origem especificado e cola-os em outro Array começando no índice de destino especificado. O comprimento e os índices são especificados como inteiros de 64 bits.
CopyTo(Array, Int32)	Copia todos os elementos da matriz unidimensional atual para a matriz unidimensional especificada começando no índice de matriz de destino especificado. O índice é especificado como um inteiro de 32 bits.
CopyTo(Array, Int64)	Copia todos os elementos da matriz unidimensional atual para a matriz unidimensional especificada começando no índice de matriz de destino especificado. O índice é especificado como um inteiro de 64 bits.
CreateInstance(Type, Int32)	Cria uma Array unidimensional do Type e do comprimento especificados, com indexação baseada em zero.
CreateInstance(Type, Int32, Int32)	Cria uma Array bidimensional dos comprimentos de Type e dimensão especificados, com indexação baseada em zero.
CreateInstance(Type, Int32, Int32, Int32)	Cria uma Array tridimensional dos comprimentos de Type e dimensão especificados, com indexação baseada em zero.
CreateInstance(Type, Int32[])	Cria uma Array multidimensional dos comprimentos de Type e dimensão especificados, com indexação baseada em zero. Os comprimentos de dimensão são especificados em uma matriz de inteiros de 32 bits.
CreateInstance(Type, Int32[], Int32[])	Cria uma Array multidimensional dos comprimentos de Type e dimensão especificados, com os limites inferiores especificados.
CreateInstance(Type, Int64[])	Cria uma Array multidimensional dos comprimentos de Type e dimensão especificados, com indexação baseada em zero. Os comprimentos de dimensão são especificados em uma matriz de inteiros de 64 bits.
Empty<T>()	Retorna uma matriz vazia.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
Exists<T>(T[], Predicate<T>)	Determina se a matriz especificada contém elementos que correspondem às condições definidas pelo predicado especificado.
Fill<T>(T[], T)	Atribui o value fornecido do tipo T a cada elemento do arrayespecificado.
Fill<T>(T[], T, Int32, Int32)	Atribui o value fornecido do tipo T aos elementos do array especificado que estão dentro do intervalo de startIndex (inclusivo) e o próximo count número de índices.
Find<T>(T[], Predicate<T>)	Pesquisa um elemento que corresponde às condições definidas pelo predicado especificado e retorna a primeira ocorrência dentro de todo o Array.
FindAll<T>(T[], Predicate<T>)	Recupera todos os elementos que correspondem às condições definidas pelo predicado especificado.
FindIndex<T>(T[], Int32, Int32, Predicate<T>)	Pesquisa um elemento que corresponde às condições definidas pelo predicado especificado e retorna o índice baseado em zero da primeira ocorrência dentro do intervalo de elementos no Array que começa no índice especificado e contém o número especificado de elementos.
FindIndex<T>(T[], Int32, Predicate<T>)	Pesquisa um elemento que corresponde às condições definidas pelo predicado especificado e retorna o índice baseado em zero da primeira ocorrência dentro do intervalo de elementos no Array que se estende do índice especificado até o último elemento.
FindIndex<T>(T[], Predicate<T>)	Pesquisa um elemento que corresponde às condições definidas pelo predicado especificado e retorna o índice baseado em zero da primeira ocorrência em todo o Array.
FindLast<T>(T[], Predicate<T>)	Pesquisa um elemento que corresponde às condições definidas pelo predicado especificado e retorna a última ocorrência em todo o Array.
FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)	Pesquisa um elemento que corresponde às condições definidas pelo predicado especificado e retorna o índice baseado em zero da última ocorrência dentro do intervalo de elementos no Array que contém o número especificado de elementos e termina no índice especificado.
FindLastIndex<T>(T[], Int32, Predicate<T>)	Pesquisa um elemento que corresponde às condições definidas pelo predicado especificado e retorna o índice baseado em zero da última ocorrência dentro do intervalo de elementos no Array que se estende do primeiro elemento para o índice especificado.
FindLastIndex<T>(T[], Predicate<T>)	Pesquisa um elemento que corresponde às condições definidas pelo predicado especificado e retorna o índice baseado em zero da última ocorrência em todo o Array.
ForEach<T>(T[], Action<T>)	Executa a ação especificada em cada elemento da matriz especificada.
GetEnumerator()	Retorna um IEnumerator para o Array.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetLength(Int32)	Obtém um inteiro de 32 bits que representa o número de elementos na dimensão especificada do Array.
GetLongLength(Int32)	Obtém um inteiro de 64 bits que representa o número de elementos na dimensão especificada do Array.
GetLowerBound(Int32)	Obtém o índice do primeiro elemento da dimensão especificada na matriz.
GetType()	Obtém o Type da instância atual. (Herdado de Object)
GetUpperBound(Int32)	Obtém o índice do último elemento da dimensão especificada na matriz.
GetValue(Int32)	Obtém o valor na posição especificada no Arrayunidimensional. O índice é especificado como um inteiro de 32 bits.
GetValue(Int32, Int32)	Obtém o valor na posição especificada no Arraybidimensional. Os índices são especificados como inteiros de 32 bits.
GetValue(Int32, Int32, Int32)	Obtém o valor na posição especificada no Arraytridimensional. Os índices são especificados como inteiros de 32 bits.
GetValue(Int32[])	Obtém o valor na posição especificada no Arraymultidimensional. Os índices são especificados como uma matriz de inteiros de 32 bits.
GetValue(Int64)	Obtém o valor na posição especificada no Arrayunidimensional. O índice é especificado como um inteiro de 64 bits.
GetValue(Int64, Int64)	Obtém o valor na posição especificada no Arraybidimensional. Os índices são especificados como inteiros de 64 bits.
GetValue(Int64, Int64, Int64)	Obtém o valor na posição especificada no Arraytridimensional. Os índices são especificados como inteiros de 64 bits.
GetValue(Int64[])	Obtém o valor na posição especificada no Arraymultidimensional. Os índices são especificados como uma matriz de inteiros de 64 bits.
IndexOf(Array, Object)	Pesquisa o objeto especificado e retorna o índice de sua primeira ocorrência em uma matriz unidimensional.
IndexOf(Array, Object, Int32)	Pesquisa o objeto especificado em um intervalo de elementos de uma matriz unidimensional e retorna o índice de sua primeira ocorrência. O intervalo se estende de um índice especificado até o final da matriz.
IndexOf(Array, Object, Int32, Int32)	Pesquisa o objeto especificado em um intervalo de elementos de uma matriz unidimensional e retorna o índice de ifs primeira ocorrência. O intervalo se estende de um índice especificado para um número especificado de elementos.
IndexOf<T>(T[], T)	Pesquisa o objeto especificado e retorna o índice de sua primeira ocorrência em uma matriz unidimensional.
IndexOf<T>(T[], T, Int32)	Pesquisa o objeto especificado em um intervalo de elementos de uma matriz unidimensional e retorna o índice de sua primeira ocorrência. O intervalo se estende de um índice especificado até o final da matriz.
IndexOf<T>(T[], T, Int32, Int32)	Pesquisa o objeto especificado em um intervalo de elementos de uma matriz unidimensional e retorna o índice de sua primeira ocorrência. O intervalo se estende de um índice especificado para um número especificado de elementos.
Initialize()	Inicializa cada elemento do tipo de valor Array chamando o construtor sem parâmetros do tipo de valor.
LastIndexOf(Array, Object)	Pesquisa o objeto especificado e retorna o índice da última ocorrência dentro de todo o Arrayunidimensional.
LastIndexOf(Array, Object, Int32)	Pesquisa o objeto especificado e retorna o índice da última ocorrência dentro do intervalo de elementos no Array unidimensional que se estende do primeiro elemento para o índice especificado.
LastIndexOf(Array, Object, Int32, Int32)	Pesquisa o objeto especificado e retorna o índice da última ocorrência dentro do intervalo de elementos no Array unidimensional que contém o número especificado de elementos e termina no índice especificado.
LastIndexOf<T>(T[], T)	Pesquisa o objeto especificado e retorna o índice da última ocorrência em todo o Array.
LastIndexOf<T>(T[], T, Int32)	Pesquisa o objeto especificado e retorna o índice da última ocorrência dentro do intervalo de elementos no Array que se estende do primeiro elemento para o índice especificado.
LastIndexOf<T>(T[], T, Int32, Int32)	Pesquisa o objeto especificado e retorna o índice da última ocorrência dentro do intervalo de elementos no Array que contém o número especificado de elementos e termina no índice especificado.
MemberwiseClone()	Cria uma cópia superficial do Objectatual. (Herdado de Object)
Resize<T>(T[], Int32)	Altera o número de elementos de uma matriz unidimensional para o novo tamanho especificado.
Reverse(Array)	Inverte a sequência dos elementos em toda a Arrayunidimensional.
Reverse(Array, Int32, Int32)	Inverte a sequência de um subconjunto dos elementos no Arrayunidimensional.
Reverse<T>(T[])	Inverte a sequência dos elementos na matriz genérica unidimensional.
Reverse<T>(T[], Int32, Int32)	Inverte a sequência de um subconjunto dos elementos na matriz genérica unidimensional.
SetValue(Object, Int32)	Define um valor para o elemento na posição especificada no Arrayunidimensional. O índice é especificado como um inteiro de 32 bits.
SetValue(Object, Int32, Int32)	Define um valor para o elemento na posição especificada no Arraybidimensional. Os índices são especificados como inteiros de 32 bits.
SetValue(Object, Int32, Int32, Int32)	Define um valor para o elemento na posição especificada no Arraytridimensional. Os índices são especificados como inteiros de 32 bits.
SetValue(Object, Int32[])	Define um valor para o elemento na posição especificada no Arraymultidimensional. Os índices são especificados como uma matriz de inteiros de 32 bits.
SetValue(Object, Int64)	Define um valor para o elemento na posição especificada no Arrayunidimensional. O índice é especificado como um inteiro de 64 bits.
SetValue(Object, Int64, Int64)	Define um valor para o elemento na posição especificada no Arraybidimensional. Os índices são especificados como inteiros de 64 bits.
SetValue(Object, Int64, Int64, Int64)	Define um valor para o elemento na posição especificada no Arraytridimensional. Os índices são especificados como inteiros de 64 bits.
SetValue(Object, Int64[])	Define um valor para o elemento na posição especificada no Arraymultidimensional. Os índices são especificados como uma matriz de inteiros de 64 bits.
Sort(Array)	Classifica os elementos em uma Array unidimensional inteira usando a implementação IComparable de cada elemento do Array.
Sort(Array, Array)	Classifica um par de objetos Array unidimensionais (um contém as chaves e o outro contém os itens correspondentes) com base nas chaves na primeira Array usando a implementação IComparable de cada chave.
Sort(Array, Array, IComparer)	Classifica um par de objetos Array unidimensionais (um contém as chaves e o outro contém os itens correspondentes) com base nas chaves no primeiro Array usando o IComparerespecificado.
Sort(Array, Array, Int32, Int32)	Classifica um intervalo de elementos em um par de objetos Array unidimensionais (um contém as chaves e o outro contém os itens correspondentes) com base nas chaves na primeira Array usando a implementação IComparable de cada chave.
Sort(Array, Array, Int32, Int32, IComparer)	Classifica um intervalo de elementos em um par de objetos Array unidimensionais (um contém as chaves e o outro contém os itens correspondentes) com base nas chaves no primeiro Array usando o IComparerespecificado.
Sort(Array, IComparer)	Classifica os elementos em um Array unidimensional usando o IComparerespecificado.
Sort(Array, Int32, Int32)	Classifica os elementos em um intervalo de elementos em uma Array unidimensional usando a implementação IComparable de cada elemento do Array.
Sort(Array, Int32, Int32, IComparer)	Classifica os elementos em um intervalo de elementos em um Array unidimensional usando o IComparerespecificado.
Sort<T>(T[])	Classifica os elementos em uma Array inteira usando a implementação de interface genérica IComparable<T> de cada elemento do Array.
Sort<T>(T[], Comparison<T>)	Classifica os elementos em um Array usando o Comparison<T>especificado.
Sort<T>(T[], IComparer<T>)	Classifica os elementos em um Array usando a interface genérica IComparer<T> especificada.
Sort<T>(T[], Int32, Int32)	Classifica os elementos em um intervalo de elementos em um Array usando a implementação de interface genérica IComparable<T> de cada elemento do Array.
Sort<T>(T[], Int32, Int32, IComparer<T>)	Classifica os elementos em um intervalo de elementos em um Array usando a interface genérica IComparer<T> especificada.
Sort<TKey,TValue>(TKey[], TValue[])	Classifica um par de objetos Array (um contém as chaves e o outro contém os itens correspondentes) com base nas chaves no primeiro Array usando a implementação de interface genérica IComparable<T> de cada chave.
Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>)	Classifica um par de objetos Array (um contém as chaves e o outro contém os itens correspondentes) com base nas chaves no primeiro Array usando a interface genérica IComparer<T> especificada.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32)	Classifica um intervalo de elementos em um par de objetos Array (um contém as chaves e o outro contém os itens correspondentes) com base nas chaves na primeira Array usando o IComparable<T> implementação de interface genérica de cada chave.
Sort<TKey,TValue>(TKey[], TValue[], Int32, Int32, IComparer<TKey>)	Classifica um intervalo de elementos em um par de objetos Array (um contém as chaves e o outro contém os itens correspondentes) com base nas chaves no primeiro Array usando a interface genérica IComparer<T> especificada.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)
TrueForAll<T>(T[], Predicate<T>)	Determina se cada elemento na matriz corresponde às condições definidas pelo predicado especificado.

Implantações explícitas de interface

ICollection.Count	Obtém o número de elementos contidos no Array.
IList.Add(Object)	Chamar esse método sempre gera uma exceção NotSupportedException.
IList.Clear()	Remove todos os itens do IList.
IList.Contains(Object)	Determina se um elemento está no IList.
IList.IndexOf(Object)	Determina o índice de um item específico no IList.
IList.Insert(Int32, Object)	Insere um item no IList no índice especificado.
IList.Item[Int32]	Obtém ou define o elemento no índice especificado.
IList.Remove(Object)	Remove a primeira ocorrência de um objeto específico do IList.
IList.RemoveAt(Int32)	Remove o item IList no índice especificado.
IStructuralComparable.CompareTo(Object, IComparer)	Determina se o objeto de coleção atual precede, ocorre na mesma posição ou segue outro objeto na ordem de classificação.
IStructuralEquatable.Equals(Object, IEqualityComparer)	Determina se um objeto é igual à instância atual.
IStructuralEquatable.GetHashCode(IEqualityComparer)	Retorna um código hash para a instância atual.

Métodos de Extensão

Cast<TResult>(IEnumerable)	Converte os elementos de um IEnumerable para o tipo especificado.
OfType<TResult>(IEnumerable)	Filtra os elementos de um IEnumerable com base em um tipo especificado.
AsParallel(IEnumerable)	Habilita a paralelização de uma consulta.
AsQueryable(IEnumerable)	Converte um IEnumerable em um IQueryable.

Acesso thread-safe

Membros estáticos públicos (Shared no Visual Basic) desse tipo são thread safe. Não há garantia de que os membros de instância sejam thread safe.

Essa implementação não fornece um wrapper sincronizado (thread safe) para um Array; no entanto, as classes .NET com base em Array fornecem sua própria versão sincronizada da coleção usando a propriedade SyncRoot.

Enumerar por meio de uma coleção não é intrinsecamente um procedimento thread-safe. Mesmo quando uma coleção é sincronizada, outros threads ainda podem modificar a coleção, o que faz com que o enumerador gere uma exceção. Para garantir a segurança do thread durante a enumeração, você pode bloquear a coleção durante toda a enumeração ou capturar as exceções resultantes de alterações feitas por outros threads.

Confira também

• Object
• Type
• executando operações de cadeia de caracteres Culture-Insensitive em matrizes
• matrizes (Guia de Programação em C#)
• Matrizes em F#
• matrizes de no Visual Basic