Array Classe

Definição

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 : System::Collections::IList, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable
public ref class Array abstract : ICloneable, System::Collections::IList, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable
public ref class Array abstract : ICloneable, System::Collections::IList
public abstract class Array : System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
public abstract class Array : ICloneable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
[System.Serializable]
public abstract class Array : ICloneable, System.Collections.IList
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public abstract class Array : ICloneable, System.Collections.IList
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
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
type Array = class
    interface ICollection
    interface IEnumerable
    interface IList
    interface IStructuralComparable
    interface IStructuralEquatable
    interface ICloneable
[<System.Serializable>]
type Array = class
    interface ICloneable
    interface IList
    interface ICollection
    interface IEnumerable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Array = class
    interface ICloneable
    interface IList
    interface ICollection
    interface IEnumerable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Array = class
    interface ICloneable
    interface IList
    interface ICollection
    interface IEnumerable
    interface IStructuralComparable
    interface IStructuralEquatable
type Array = class
    interface IList
    interface ICollection
    interface IEnumerable
    interface IStructuralComparable
    interface IStructuralEquatable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Array = class
    interface ICloneable
    interface ICollection
    interface IList
    interface IEnumerable
    interface IStructuralComparable
    interface IStructuralEquatable
Public MustInherit Class Array
Implements IList, IStructuralComparable, IStructuralEquatable
Public MustInherit Class Array
Implements ICloneable, IList, IStructuralComparable, IStructuralEquatable
Public MustInherit Class Array
Implements ICloneable, IList
Herança
Array
Atributos
Implementações

Exemplos

O exemplo de código a seguir mostra como Array.Copy copia elementos entre uma matriz de tipo inteiro 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 Array classe não faz parte dos System.Collections namespaces. No entanto, ela ainda é considerada uma coleção porque se baseia na IList interface.

A Array classe é 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 Array classe. 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. Uma 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 Array classe usando CreateInstance. Um multidimensional Array pode ter limites diferentes para cada dimensão. Uma matriz pode ter no máximo 32 dimensões.

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

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 determinada (0X7FFFFFC7 para matrizes de bytes e matrizes de estruturas de bytes únicos).

.NET Framework somente: 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 enabled atributo do elemento de configuração gcAllowVeryLargeObjects no true ambiente de tempo de execução.

Matrizes unidimensionais implementam as System.Collections.Generic.IList<T>interfaces genérica e , e , System.Collections.Generic.ICollection<T>System.Collections.Generic.IEnumerable<T>System.Collections.Generic.IReadOnlyList<T> 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 Array classe. 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 explícitas da interface). O importante a ser ciente quando você converte uma matriz em uma dessas interfaces é que os membros que adicionam, inserem ou removem elementos são lançados NotSupportedException.

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

Type.IsArray e Type.GetElementType talvez não retorne os resultados esperados porque Array 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 Array.Copy método 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, CopyToe GetValueSetValue, fornecem sobrecargas que aceitam inteiros de 64 bits como parâmetros para acomodar grandes matrizes de capacidade. LongLength e GetLongLength retornar inteiros de 64 bits indicando o comprimento da matriz.

Não Array há garantia de classificação. Você deve classificar as Array operações anteriores à execução (como BinarySearch) que exigem a classificação Array .

Não há suporte para o uso de um Array objeto 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 à 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 unidimensional classificada para um valor, usando a interface IComparable implementada por cada elemento da matriz e pelo valor especificado.

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

Pesquisa uma variedade de elementos em uma matriz classificada unidimensional para um valor usando a interface IComparer especificada.

BinarySearch(Array, Object)

Pesquisa uma matriz unidimensional inteira classificada por um elemento específico, usando a IComparable interface implementada por cada elemento da matriz e o objeto especificado.

BinarySearch(Array, Object, IComparer)

Pesquisa um valor usando a interface IComparer especificada em uma matriz classificada unidimensional inteira.

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

Pesquisa um intervalo de elementos em uma matriz unidimensional classificada em busca de um valor, usando a interface genérica IComparable<T> implementada por cada elemento do Array e pelo valor especificado.

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

Pesquisa uma variedade de elementos em uma matriz classificada unidimensional para um valor usando a interface genérica de IComparer<T> especificada.

BinarySearch<T>(T[], T)

Pesquisa uma matriz unidimensional inteira classificada por um elemento específico, usando a interface IComparable<T> genérica implementada por cada elemento da Array e o objeto especificado.

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

Pesquisa uma matriz classificada unidimensional completa para um valor usando a interface genérica de IComparer<T> especificada.

Clear(Array)

Limpa o conteúdo de uma matriz.

Clear(Array, Int32, Int32)

Define um intervalo de elementos em uma matriz como 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 a partir do índice de origem especificado e cola-os em outro Array a partir do índice de destino especificado. Garante que todas as alterações serão desfeitas se a cópia não foi bem-sucedida por completo.

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

Converte uma matriz de um tipo para uma matriz de outro tipo.

Copy(Array, Array, Int32)

Copia um intervalo de elementos de uma Array iniciando no primeiro elemento e cola-o em outro Array, iniciando no primeiro elemento. O comprimento é especificado como um inteiro de 32 bits.

Copy(Array, Array, Int64)

Copia um intervalo de elementos de uma Array iniciando no primeiro elemento e cola-o em outro Array, iniciando no primeiro elemento. O tamanho é especificado como um inteiro de 64 bits.

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

Copia um intervalo de elementos de um Array a partir do índice de origem especificado e cola-os em outro Array a partir do índice de destino especificado. A altura 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 a partir do índice de origem especificado e cola-os em outro Array a partir do índice de destino especificado. O tamanho 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 um Array unidimensional do Type especificado e tamanho, com a indexação com base em zero.

CreateInstance(Type, Int32, Int32)

Cria um Array bidimensional do Type e comprimentos de dimensão especificados, com a indexação com base em zero.

CreateInstance(Type, Int32, Int32, Int32)

Cria um Array tridimensional do Type e comprimentos de dimensão especificados, com a indexação com base em zero.

CreateInstance(Type, Int32[])

Cria um Array multidimensional do Type e comprimentos de dimensão especificados, com a indexação com base zero. Os tamanhos da dimensão são especificados em uma matriz de inteiros de 32 bits.

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

Cria um Array multidimensional com o Type especificado e com os tamanhos da dimensão, com os limites inferiores especificados.

CreateInstance(Type, Int64[])

Cria um Array multidimensional do Type e comprimentos de dimensão especificados, com a indexação com base zero. Os tamanhos da 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 de tipo T a cada elemento de array especificado.

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

Atribui o value fornecido de tipo T aos elementos de array especificado que estão dentro do intervalo de startIndex (inclusive) e o próximo número count 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 em toda a 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 coincida com as condições definidas pelo predicado especificado e retorna o índice baseado em zero da primeira ocorrência dentro do intervalo de elementos na Array que começa no índice especificado e contém o número de elementos especificado.

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

Pesquisa um elemento que corresponda à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 ao ú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 toda a Array.

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

Pesquisa um elemento que corresponda às condições definidas pelo predicado especificado e retorna a primeira ocorrência em toda a Array.

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

Pesquisa por um elemento que corresponda às condições definidas pelo predicado especificado e retorna o índice baseado em zero da última ocorrência no intervalo de elementos no Array que contém o número de elementos especificado 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 ao í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 toda a 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 Array unidimensional. O índice é especificado como um inteiro de 32 bits.

GetValue(Int32, Int32)

Obtém o valor na posição especificada no Array bidimensional. Os índices são especificados como inteiro de 32 bits.

GetValue(Int32, Int32, Int32)

Obtém o valor na posição especificada no Array tridimensional. Os índices são especificados como inteiro de 32 bits.

GetValue(Int32[])

Obtém o valor na posição especificada no Array multidimensional. Os índices são especificados como uma matriz de inteiros de 32 bits.

GetValue(Int64)

Obtém o valor na posição especificada no Array unidimensional. O índice é especificado como um inteiro de 64 bits.

GetValue(Int64, Int64)

Obtém o valor na posição especificada no Array bidimensional. Os índices são especificados como inteiros de 64 bits.

GetValue(Int64, Int64, Int64)

Obtém o valor na posição especificada no Array tridimensional. Os índices são especificados como inteiros de 64 bits.

GetValue(Int64[])

Obtém o valor na posição especificada no Array multidimensional. Os índices são especificados como uma matriz de inteiros de 64 bits.

IndexOf(Array, Object)

Pesquisa o objeto especificado e retorna o índice da 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 da primeira ocorrência. O intervalo se estende de um índice especificado ao final da matriz.

IndexOf(Array, Object, Int32, Int32)

Pesquisa pelo objeto especificado em um intervalo de elementos de uma matriz unidimensional e retorna o índice da primeira ocorrência. O intervalo estende-se de um índice especificado a um número especificado de elementos.

IndexOf<T>(T[], T)

Pesquisa o objeto especificado e retorna o índice da 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 da primeira ocorrência. O intervalo se estende de um índice especificado ao 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 da primeira ocorrência. O intervalo estende-se de um índice especificado a um número especificado de elementos.

Initialize()

Inicializa todos os elementos 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 toda a Array unidimensional.

LastIndexOf(Array, Object, Int32)

Procura 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 ao índice especificado.

LastIndexOf(Array, Object, Int32, Int32)

Pesquisa o objeto especificado e retorna o índice da última ocorrência no intervalo de elementos no Array unidimensional que contém o número de elementos especificado e termina no índice especificado.

LastIndexOf<T>(T[], T)

Pesquisa o objeto especificado e retorna o índice da última ocorrência dentro de toda a Array.

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

Procura o objeto especificado e retorna o índice da última ocorrência dentro do intervalo de elementos em Array que se estende do primeiro elemento ao índice especificado.

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

Pesquisa o objeto especificado e retorna o índice da última ocorrência no intervalo de elementos na Array que contém o número de elementos especificado e termina no índice especificado.

MemberwiseClone()

Cria uma cópia superficial do Object atual.

(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 todo o Array unidimensional.

Reverse(Array, Int32, Int32)

Inverte a sequência de um subconjunto dos elementos na Array unidimensional.

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 como o elemento na posição especificada no Array unidimensional. O índice é especificado como um inteiro de 32 bits.

SetValue(Object, Int32, Int32)

Define um valor como o elemento na posição especificada no Array bidimensional. Os índices são especificados como inteiro de 32 bits.

SetValue(Object, Int32, Int32, Int32)

Define um valor como o elemento na posição especificada no Array tridimensional. Os índices são especificados como inteiro de 32 bits.

SetValue(Object, Int32[])

Define um valor para o elemento na posição especificada na Array multidimensional. Os índices são especificados como uma matriz de inteiros de 32 bits.

SetValue(Object, Int64)

Define um valor como o elemento na posição especificada no Array unidimensional. O índice é especificado como um inteiro de 64 bits.

SetValue(Object, Int64, Int64)

Define um valor como o elemento na posição especificada no Array bidimensional. Os índices são especificados como inteiros de 64 bits.

SetValue(Object, Int64, Int64, Int64)

Define um valor como o elemento na posição especificada no Array tridimensional. Os índices são especificados como inteiros de 64 bits.

SetValue(Object, Int64[])

Define um valor para o elemento na posição especificada na Array multidimensional. Os índices são especificados como uma matriz de inteiros de 64 bits.

Sort(Array)

Classifica os elementos em todo um Array unidimensional 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 no primeiro Array usando a implementação IComparable de cada chave.

Sort(Array, Array, IComparer)

Classifica um par 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 IComparer especificado.

Sort(Array, Array, Int32, Int32)

Classifica um intervalo de elementos em um par de objetos Array unidirecionais (um contém as chaves e o outro contém os itens correspondentes) com base nas chaves do primeiro Array usando a implementação IComparable de cada chave.

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

Classifica uma gama 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 IComparer especificado.

Sort(Array, IComparer)

Classifica os elementos em um Array unidimensional usando o IComparer especificado.

Sort(Array, Int32, Int32)

Classifica os elementos em um intervalo de elementos em um 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 IComparer especificado.

Sort<T>(T[])

Classifica os elementos em todo um Array usando a implementação de interface genérica do 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 do 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 outro contém os itens correspondentes) com base nas chaves no primeiro Array usando a implementação da 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 uma gama de elementos em um par de objetos Array (um contém as chaves e outro contém os itens correspondentes) com base nas chaves no primeiro Array usando a implementação da interface genérica IComparable<T> de cada chave.

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

Classifica uma gama 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.

ICollection.IsSynchronized

Obtém um valor que indica se o acesso ao Array é sincronizado (thread-safe).

ICollection.SyncRoot

Obtém um objeto que pode ser usado para sincronizar o acesso ao Array.

IList.Add(Object)

A chamada desse 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 em IList.

IList.Insert(Int32, Object)

Insere um item na IList no índice especificado.

IList.IsFixedSize

Obtém um valor que indica se o Array tem um tamanho fixo.

IList.IsReadOnly

Obtém um valor que indica se o Array é somente leitura.

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 da coleção atual precede, ocorre na mesma posição ou segue a 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.

Aplica-se a

Acesso thread-safe

Os membros estáticos públicos (Shared no Visual Basic) desse são thread-safe. Não há garantia de que qualquer membro de instância seja seguro para threads.

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

A enumeração por meio de uma coleção não é um procedimento thread-safe intrínseco. Mesmo quando uma coleção está sincronizada, outros threads ainda podem modificar a coleção, o que faz o enumerador lançar uma exceção. Para garantir thread-safe durante a enumeração, é possível bloquear a coleção durante toda a enumeração ou verificar as exceções resultantes das alterações feitas por outros threads.

Confira também