Array Array Array Array Class

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. Provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the base class for all arrays in the common language runtime.

public ref class Array abstract : ICloneable, System::Collections::IList, System::Collections::IStructuralComparable, System::Collections::IStructuralEquatable
[System.Runtime.InteropServices.ComVisible(true)]
[Serializable]
public abstract class Array : ICloneable, System.Collections.IList, System.Collections.IStructuralComparable, System.Collections.IStructuralEquatable
type Array = class
    interface ICloneable
    interface ICollection
    interface IList
    interface IEnumerable
    interface IStructuralComparable
    interface IStructuralEquatable
Public MustInherit Class Array
Implements ICloneable, IList, IStructuralComparable, IStructuralEquatable
Herança
ArrayArrayArrayArray
Atributos
ComVisibleAttribute SerializableAttribute
Implementações

Exemplos

O seguinte exemplo de código mostra como Array.Copy copia os elementos entre uma matriz do tipo inteiro e uma matriz do tipo Object.The following code example shows how Array.Copy copies elements between an array of type integer and an array of type Object.

using namespace System;

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

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

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

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

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

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

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

	}
	Console::WriteLine();
}

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

	}
	Console::WriteLine();
}


/*
This code produces the following output.

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

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

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

    Public Shared Sub Main()

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

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

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

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

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

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

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

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

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

O exemplo de código a seguir cria e inicializa um Array e exibe suas propriedades e seus elementos.The following code example creates and initializes an Array and displays its properties and its elements.

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

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

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

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

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

   Console::WriteLine();
}

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

    Public Shared Sub Main()

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

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

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

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

Comentários

O Array classe não é parte do System.Collections namespaces.The Array class is not part of the System.Collections namespaces. No entanto, ela ainda será considerada uma coleção porque ele se baseia o IList interface.However, it is still considered a collection because it is based on the IList interface.

O Array classe é a classe base para implementações de linguagem que dão suporte a matrizes.The Array class is the base class for language implementations that support arrays. No entanto, somente o sistema e os compiladores podem derivar explicitamente o Array classe.However, only the system and compilers can derive explicitly from the Array class. Os usuários devem empregar as construções de matriz fornecidas pela linguagem.Users should employ the array constructs provided by the language.

Um elemento é um valor em um Array.An element is a value in an Array. O comprimento de um Array é o número total de elementos que ele pode conter.The length of an Array is the total number of elements it can contain. O limite inferior de um Array é o índice do seu primeiro elemento.The lower bound of an Array is the index of its first element. Um Array pode ter qualquer limite inferior, mas ele tem um limite inferior de zero por padrão.An Array can have any lower bound, but it has a lower bound of zero by default. Um limite inferior diferente pode ser definido ao criar uma instância das Array classe usando CreateInstance. Um multidimensional Array pode ter diferentes limites de cada dimensão.A different lower bound can be defined when creating an instance of the Array class using CreateInstance.A multidimensional Array can have different bounds for each dimension. Uma matriz pode ter um máximo de 32 dimensões.An array can have a maximum of 32 dimensions.

Ao contrário das classes na System.Collections namespaces, Array tem uma capacidade fixa.Unlike the classes in the System.Collections namespaces, Array has a fixed capacity. Para aumentar a capacidade, você deve criar um novo Array de objeto com a capacidade necessária, copiar os elementos do ambiente antigo Array do objeto para o novo e excluir o antigo Array.To increase the capacity, you must create a new Array object with the required capacity, copy the elements from the old Array object to the new one, and delete the old Array.

Por padrão, o tamanho máximo de um Array é de 2 gigabytes (GB).By default, the maximum size of an Array is 2 gigabytes (GB). Em um ambiente de 64 bits, você pode evitar a restrição de tamanho, definindo o enabled atributo o gcAllowVeryLargeObjects elemento de configuração para true no ambiente de tempo de execução.In a 64-bit environment, you can avoid the size restriction by setting the enabled attribute of the gcAllowVeryLargeObjects configuration element to true in the run-time environment. No entanto, a matriz ainda estará limitada a um total de 4 bilhões de elementos e a um índice máximo de 0X7FEFFFFF em qualquer determinada dimensão (0X7FFFFFC7 para matrizes de bytes e matrizes de estruturas de byte único).However, the array will still be limited to a total of 4 billion elements, and to a maximum index of 0X7FEFFFFF in any given dimension (0X7FFFFFC7 for byte arrays and arrays of single-byte structures).

Matrizes unidimensionais implementam o 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> interfaces genéricas.Single-dimensional arrays implement the System.Collections.Generic.IList<T>, System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyList<T> and System.Collections.Generic.IReadOnlyCollection<T> generic interfaces. As implementações são fornecidas para matrizes em tempo de execução e como resultado, as interfaces genéricas não aparecem na sintaxe de declaração para o Array classe.The implementations are provided to arrays at run time, and as a result, the generic interfaces do not appear in the declaration syntax for the Array class. Além disso, não há nenhum tópicos de referência para os membros de interface que são acessíveis apenas ao converter uma matriz para o tipo de interface genérica (implementações explícitas da interface).In addition, there are no reference topics for interface members that are accessible only by casting an array to the generic interface type (explicit interface implementations). O que é importante estar atento ao converter uma matriz para uma dessas interfaces é que os membros que adicionar, inserir ou remover elementos throw NotSupportedException.The key thing to be aware of when you cast an array to one of these interfaces is that members which add, insert, or remove elements throw NotSupportedException.

Type objetos fornecem informações sobre declarações de tipo de matriz.Type objects provide information about array type declarations. Array objetos com o mesmo tipo de matriz compartilham o mesmo Type objeto.Array objects with the same array type share the same Type object.

Type.IsArray e Type.GetElementType podem não retornar os resultados esperados com Array porque se uma matriz é convertida para o tipo Array, o resultado é um objeto, não é uma matriz.Type.IsArray and Type.GetElementType might not return the expected results with Array because if an array is cast to the type Array, the result is an object, not an array. Ou seja, typeof(System.Array).IsArray retorna false, e typeof(System.Array).GetElementType retorna null.That is, typeof(System.Array).IsArray returns false, and typeof(System.Array).GetElementType returns null.

O Array.Copy método copia não apenas entre matrizes do mesmo tipo, mas também entre matrizes de padrão de tipos diferentes de elementos; ele trata automaticamente de conversão de tipo.The Array.Copy method copies elements not only between arrays of the same type but also between standard arrays of different types; it handles type casting automatically.

Alguns métodos, tais como CreateInstance, Copy, CopyTo, GetValue, e SetValue, fornecem sobrecargas que aceitam números inteiros de 64 bits como parâmetros para acomodar as matrizes de grande capacidade.Some methods, such as CreateInstance, Copy, CopyTo, GetValue, and SetValue, provide overloads that accept 64-bit integers as parameters to accommodate large capacity arrays. LongLength e GetLongLength retornam inteiros de 64 bits que indica o comprimento da matriz.LongLength and GetLongLength return 64-bit integers indicating the length of the array.

O Array não é garantida a serem classificados.The Array is not guaranteed to be sorted. Você deve classificar as Array antes de executar operações (como BinarySearch) que exigem o Array a serem classificados.You must sort the Array prior to performing operations (such as BinarySearch) that require the Array to be sorted.

Usando um Array objeto de ponteiros em código nativo não é compatível e gerará um NotSupportedException para vários métodos.Using an Array object of pointers in native code is not supported and will throw a NotSupportedException for several methods.

Propriedades

IsFixedSize IsFixedSize IsFixedSize IsFixedSize

Obtém um valor que indica se o Array tem um tamanho fixo. Gets a value indicating whether the Array has a fixed size.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Obtém um valor que indica se o Array é somente leitura. Gets a value indicating whether the Array is read-only.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

Obtém um valor que indica se o acesso à Array é sincronizado (thread-safe). Gets a value indicating whether access to the Array is synchronized (thread safe).

Length Length Length Length

Obtém o número total de elementos em todas as dimensões do Array. Gets the total number of elements in all the dimensions of the Array.

LongLength LongLength LongLength LongLength

Obtém um inteiro de 64 bits que representa o número total de elementos em todas as dimensões do Array. Gets a 64-bit integer that represents the total number of elements in all the dimensions of the Array.

Rank Rank Rank Rank

Obtém a classificação (número de dimensões) do Array. Gets the rank (number of dimensions) of the Array. Por exemplo, uma matriz unidimensional retorna 1, uma matriz bidimensional retorna 2 e assim por diante. For example, a one-dimensional array returns 1, a two-dimensional array returns 2, and so on.

SyncRoot SyncRoot SyncRoot SyncRoot

Obtém um objeto que pode ser usado para sincronizar o acesso ao Array. Gets an object that can be used to synchronize access to the Array.

Métodos

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

Retorna um wrapper somente leitura para a matriz especificada. Returns a read-only wrapper for the specified array.

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

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. Searches a range of elements in a one-dimensional sorted array for a value, using the IComparable interface implemented by each element of the array and by the specified value.

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

Pesquisa uma variedade de elementos em uma matriz classificada unidimensional para um valor usando a interface IComparer especificada. Searches a range of elements in a one-dimensional sorted array for a value, using the specified IComparer interface.

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

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. Searches an entire one-dimensional sorted array for a specific element, using the IComparable interface implemented by each element of the array and by the specified object.

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

Pesquisa um valor usando a interface IComparer especificada em uma matriz classificada unidimensional inteira. Searches an entire one-dimensional sorted array for a value using the specified IComparer interface.

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

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. Searches a range of elements in a one-dimensional sorted array for a value, using the IComparable<T> generic interface implemented by each element of the Array and by the specified value.

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

Pesquisa uma variedade de elementos em uma matriz classificada unidimensional para um valor usando a interface genérica de IComparer<T> especificada. Searches a range of elements in a one-dimensional sorted array for a value, using the specified IComparer<T> generic interface.

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

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. Searches an entire one-dimensional sorted array for a specific element, using the IComparable<T> generic interface implemented by each element of the Array and by the specified object.

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

Pesquisa uma matriz classificada unidimensional completa para um valor usando a interface genérica de IComparer<T> especificada. Searches an entire one-dimensional sorted array for a value using the specified IComparer<T> generic interface.

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

Define um intervalo de elementos em uma matriz como o valor padrão de cada tipo de elemento. Sets a range of elements in an array to the default value of each element type.

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

Cria uma cópia superficial do Array. Creates a shallow copy of the Array.

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

Copia 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. Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. Garante que todas as alterações serão desfeitas se a cópia não foi bem-sucedida por completo. Guarantees that all changes are undone if the copy does not succeed completely.

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

Converte uma matriz de um tipo para uma matriz de outro tipo. Converts an array of one type to an array of another type.

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

Copia um intervalo de elementos de uma Array iniciando no primeiro elemento e cola-o em outro Array, iniciando no primeiro elemento. Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. O comprimento é especificado como um inteiro de 32 bits. The length is specified as a 32-bit integer.

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

Copia um intervalo de elementos de uma Array iniciando no primeiro elemento e cola-o em outro Array, iniciando no primeiro elemento. Copies a range of elements from an Array starting at the first element and pastes them into another Array starting at the first element. O tamanho é especificado como um inteiro de 64 bits. The length is specified as a 64-bit integer.

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

Copia 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. Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. A altura e os índices são especificados como inteiros de 32 bits. The length and the indexes are specified as 32-bit integers.

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

Copia 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. Copies a range of elements from an Array starting at the specified source index and pastes them to another Array starting at the specified destination index. O tamanho e os índices são especificados como inteiros de 64 bits. The length and the indexes are specified as 64-bit integers.

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

Copia todos os elementos da matriz unidimensional atual para a matriz unidimensional especificada começando no índice de matriz de destino especificado. Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. O índice é especificado como um inteiro de 32 bits. The index is specified as a 32-bit integer.

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

Copia todos os elementos da matriz unidimensional atual para a matriz unidimensional especificada começando no índice de matriz de destino especificado. Copies all the elements of the current one-dimensional array to the specified one-dimensional array starting at the specified destination array index. O índice é especificado como um inteiro de 64 bits. The index is specified as a 64-bit integer.

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

Cria um Array unidimensional do Type especificado e tamanho, com a indexação com base em zero. Creates a one-dimensional Array of the specified Type and length, with zero-based indexing.

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

Cria um Array bidimensional do Type e comprimentos de dimensão especificados, com a indexação com base em zero. Creates a two-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

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

Cria um Array tridimensional do Type e comprimentos de dimensão especificados, com a indexação com base em zero. Creates a three-dimensional Array of the specified Type and dimension lengths, with zero-based indexing.

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

Cria um Array multidimensional do Type e comprimentos de dimensão especificados, com a indexação com base zero. Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Os tamanhos da dimensão são especificados em uma matriz de inteiros de 32 bits. The dimension lengths are specified in an array of 32-bit integers.

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

Cria um Array multidimensional com o Type especificado e com os tamanhos da dimensão, com os limites inferiores especificados. Creates a multidimensional Array of the specified Type and dimension lengths, with the specified lower bounds.

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

Cria um Array multidimensional do Type e comprimentos de dimensão especificados, com a indexação com base zero. Creates a multidimensional Array of the specified Type and dimension lengths, with zero-based indexing. Os tamanhos da dimensão são especificados em uma matriz de inteiros de 64 bits. The dimension lengths are specified in an array of 64-bit integers.

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

Retorna uma matriz vazia. Returns an empty array.

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

Determina se o objeto especificado é igual ao objeto atual. Determines whether the specified object is equal to the current object.

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

Determina se a matriz especificada contém elementos que correspondem às condições definidas pelo predicado especificado. Determines whether the specified array contains elements that match the conditions defined by the specified predicate.

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

Pesquisa um elemento que corresponde às condições definidas pelo predicado especificado e retorna a primeira ocorrência em toda a Array. Searches for an element that matches the conditions defined by the specified predicate, and returns the first occurrence within the entire Array.

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

Recupera todos os elementos que correspondem às condições definidas pelo predicado especificado. Retrieves all the elements that match the conditions defined by the specified predicate.

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

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. Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the Array that starts at the specified index and contains the specified number of elements.

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

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. Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the Array that extends from the specified index to the last element.

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

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. Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire Array.

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

Pesquisa um elemento que corresponda às condições definidas pelo predicado especificado e retorna a primeira ocorrência em toda a Array. Searches for an element that matches the conditions defined by the specified predicate, and returns the last occurrence within the entire Array.

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

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. Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the Array that contains the specified number of elements and ends at the specified index.

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

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. Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the range of elements in the Array that extends from the first element to the specified index.

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

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. Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the last occurrence within the entire Array.

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

Executa a ação especificada em cada elemento da matriz especificada. Performs the specified action on each element of the specified array.

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

Retorna um IEnumerator para o Array. Returns an IEnumerator for the Array.

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

Serve como a função de hash padrão. Serves as the default hash function.

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

Obtém um inteiro de 32 bits que representa o número de elementos na dimensão especificada do Array. Gets a 32-bit integer that represents the number of elements in the specified dimension of the Array.

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

Obtém um inteiro de 64 bits que representa o número de elementos na dimensão especificada do Array. Gets a 64-bit integer that represents the number of elements in the specified dimension of the Array.

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

Obtém o índice do primeiro elemento da dimensão especificada na matriz. Gets the index of the first element of the specified dimension in the array.

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

Obtém o Type da instância atual. Gets the Type of the current instance.

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

Obtém o índice do último elemento da dimensão especificada na matriz. Gets the index of the last element of the specified dimension in the array.

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

Obtém o valor na posição especificada no Array unidimensional. Gets the value at the specified position in the one-dimensional Array. O índice é especificado como um inteiro de 32 bits. The index is specified as a 32-bit integer.

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

Obtém o valor na posição especificada no Array bidimensional. Gets the value at the specified position in the two-dimensional Array. Os índices são especificados como inteiro de 32 bits. The indexes are specified as 32-bit integers.

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

Obtém o valor na posição especificada no Array tridimensional. Gets the value at the specified position in the three-dimensional Array. Os índices são especificados como inteiro de 32 bits. The indexes are specified as 32-bit integers.

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

Obtém o valor na posição especificada no Array multidimensional. Gets the value at the specified position in the multidimensional Array. Os índices são especificados como uma matriz de inteiros de 32 bits. The indexes are specified as an array of 32-bit integers.

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

Obtém o valor na posição especificada no Array unidimensional. Gets the value at the specified position in the one-dimensional Array. O índice é especificado como um inteiro de 64 bits. The index is specified as a 64-bit integer.

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

Obtém o valor na posição especificada no Array bidimensional. Gets the value at the specified position in the two-dimensional Array. Os índices são especificados como inteiros de 64 bits. The indexes are specified as 64-bit integers.

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

Obtém o valor na posição especificada no Array tridimensional. Gets the value at the specified position in the three-dimensional Array. Os índices são especificados como inteiros de 64 bits. The indexes are specified as 64-bit integers.

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

Obtém o valor na posição especificada no Array multidimensional. Gets the value at the specified position in the multidimensional Array. Os índices são especificados como uma matriz de inteiros de 64 bits. The indexes are specified as an array of 64-bit integers.

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

Pesquisa o objeto especificado e retorna o índice da primeira ocorrência em uma matriz unidimensional. Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

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

Pesquisa o objeto especificado em um intervalo de elementos de uma matriz unidimensional e retorna o índice da primeira ocorrência. Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. O intervalo se estende de um índice especificado ao final da matriz. The range extends from a specified index to the end of the array.

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

Pesquisa pelo objeto especificado em um intervalo de elementos de uma matriz unidimensional e retorna o índice da primeira ocorrência. Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of ifs first occurrence. O intervalo estende-se de um índice especificado a um número especificado de elementos. The range extends from a specified index for a specified number of elements.

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

Pesquisa o objeto especificado e retorna o índice da primeira ocorrência em uma matriz unidimensional. Searches for the specified object and returns the index of its first occurrence in a one-dimensional array.

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

Pesquisa o objeto especificado em um intervalo de elementos de uma matriz unidimensional e retorna o índice da primeira ocorrência. Searches for the specified object in a range of elements of a one dimensional array, and returns the index of its first occurrence. O intervalo se estende de um índice especificado ao final da matriz. The range extends from a specified index to the end of the array.

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

Pesquisa o objeto especificado em um intervalo de elementos de uma matriz unidimensional e retorna o índice da primeira ocorrência. Searches for the specified object in a range of elements of a one-dimensional array, and returns the index of its first occurrence. O intervalo estende-se de um índice especificado a um número especificado de elementos. The range extends from a specified index for a specified number of elements.

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

Inicializa todos os elementos do tipo de valor Array chamando o construtor padrão do tipo de valor. Initializes every element of the value-type Array by calling the default constructor of the value type.

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

Pesquisa o objeto especificado e retorna o índice da última ocorrência dentro de toda a Array unidimensional. Searches for the specified object and returns the index of the last occurrence within the entire one-dimensional Array.

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

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

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

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. Searches for the specified object and returns the index of the last occurrence within the range of elements in the one-dimensional Array that contains the specified number of elements and ends at the specified index.

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

Pesquisa o objeto especificado e retorna o índice da última ocorrência dentro de toda a Array. Searches for the specified object and returns the index of the last occurrence within the entire Array.

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

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

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

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. Searches for the specified object and returns the index of the last occurrence within the range of elements in the Array that contains the specified number of elements and ends at the specified index.

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

Cria uma cópia superficial do Object atual. Creates a shallow copy of the current Object.

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

Altera o número de elementos de uma matriz unidimensional para o novo tamanho especificado. Changes the number of elements of a one-dimensional array to the specified new size.

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

Inverte a sequência dos elementos em todo o Array unidimensional. Reverses the sequence of the elements in the entire one-dimensional Array.

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

Inverte a sequência dos elementos em toda gama de elementos no Array unidimensional. Reverses the sequence of the elements in a range of elements in the one-dimensional Array.

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

Define um valor como o elemento na posição especificada no Array unidimensional. Sets a value to the element at the specified position in the one-dimensional Array. O índice é especificado como um inteiro de 32 bits. The index is specified as a 32-bit integer.

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

Define um valor como o elemento na posição especificada no Array bidimensional. Sets a value to the element at the specified position in the two-dimensional Array. Os índices são especificados como inteiro de 32 bits. The indexes are specified as 32-bit integers.

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

Define um valor como o elemento na posição especificada no Array tridimensional. Sets a value to the element at the specified position in the three-dimensional Array. Os índices são especificados como inteiro de 32 bits. The indexes are specified as 32-bit integers.

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

Define um valor para o elemento na posição especificada na Array multidimensional. Sets a value to the element at the specified position in the multidimensional Array. Os índices são especificados como uma matriz de inteiros de 32 bits. The indexes are specified as an array of 32-bit integers.

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

Define um valor como o elemento na posição especificada no Array unidimensional. Sets a value to the element at the specified position in the one-dimensional Array. O índice é especificado como um inteiro de 64 bits. The index is specified as a 64-bit integer.

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

Define um valor como o elemento na posição especificada no Array bidimensional. Sets a value to the element at the specified position in the two-dimensional Array. Os índices são especificados como inteiros de 64 bits. The indexes are specified as 64-bit integers.

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

Define um valor como o elemento na posição especificada no Array tridimensional. Sets a value to the element at the specified position in the three-dimensional Array. Os índices são especificados como inteiros de 64 bits. The indexes are specified as 64-bit integers.

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

Define um valor para o elemento na posição especificada na Array multidimensional. Sets a value to the element at the specified position in the multidimensional Array. Os índices são especificados como uma matriz de inteiros de 64 bits. The indexes are specified as an array of 64-bit integers.

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

Classifica os elementos em todo um Array unidimensional usando a implementação IComparable de cada elemento do Array. Sorts the elements in an entire one-dimensional Array using the IComparable implementation of each element of the Array.

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

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. Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

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

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. Sorts a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

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

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. Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable implementation of each key.

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

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. Sorts a range of elements in a pair of one-dimensional Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer.

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

Classifica os elementos em um Array unidimensional usando o IComparer especificado. Sorts the elements in a one-dimensional Array using the specified IComparer.

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

Classifica os elementos em um intervalo de elementos em um Array unidimensional usando a implementação IComparable de cada elemento do Array. Sorts the elements in a range of elements in a one-dimensional Array using the IComparable implementation of each element of the Array.

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

Classifica os elementos em um intervalo de elementos em um Array unidimensional usando o IComparer especificado. Sorts the elements in a range of elements in a one-dimensional Array using the specified IComparer.

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

Classifica os elementos em todo um Array usando a implementação de interface genérica do IComparable<T> de cada elemento do Array. Sorts the elements in an entire Array using the IComparable<T> generic interface implementation of each element of the Array.

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

Classifica os elementos em um Array usando o Comparison<T> especificado. Sorts the elements in an Array using the specified Comparison<T>.

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

Classifica os elementos em um Array usando a interface genérica IComparer<T> especificada. Sorts the elements in an Array using the specified IComparer<T> generic interface.

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

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. Sorts the elements in a range of elements in an Array using the IComparable<T> generic interface implementation of each element of the Array.

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

Classifica os elementos em um intervalo de elementos em um Array usando a interface genérica IComparer<T> especificada. Sorts the elements in a range of elements in an Array using the specified IComparer<T> generic interface.

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

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. Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

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

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. Sorts a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

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

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. Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the IComparable<T> generic interface implementation of each key.

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

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. Sorts a range of elements in a pair of Array objects (one contains the keys and the other contains the corresponding items) based on the keys in the first Array using the specified IComparer<T> generic interface.

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

Retorna uma cadeia de caracteres que representa o objeto atual. Returns a string that represents the current object.

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

Determina se cada elemento na matriz corresponde às condições definidas pelo predicado especificado. Determines whether every element in the array matches the conditions defined by the specified predicate.

Implantações explícitas de interface

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

Obtém o número de elementos contidos no Array. Gets the number of elements contained in the Array.

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

A chamada desse método sempre gera uma exceção NotSupportedException. Calling this method always throws a NotSupportedException exception.

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

Remove todos os itens do IList. Removes all items from the IList.

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

Determina se um elemento está no IList. Determines whether an element is in the IList.

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

Determina o índice de um item específico em IList. Determines the index of a specific item in the IList.

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

Insere um item na IList no índice especificado. Inserts an item to the IList at the specified index.

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

Obtém ou define o elemento no índice especificado. Gets or sets the element at the specified index.

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

Remove a primeira ocorrência de um objeto específico do IList. Removes the first occurrence of a specific object from the IList.

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

Remove o item IList no índice especificado. Removes the IList item at the specified index.

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

Determina se o objeto da coleção atual precede, ocorre na mesma posição ou segue a outro objeto na ordem de classificação. Determines whether the current collection object precedes, occurs in the same position as, or follows another object in the sort order.

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

Determina se um objeto é igual à instância atual. Determines whether an object is equal to the current instance.

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

Retorna um código hash para a instância atual. Returns a hash code for the current instance.

Aplica-se a

Acesso thread-safe

Os membros estáticos públicos (Shared no Visual Basic) desse são thread-safe. Public static (Shared in Visual Basic) members of this type are thread safe. Não há garantia de que qualquer membro de instância seja thread-safe. Any instance members are not guaranteed to be thread safe. Essa implementação não oferece um sincronizada wrapper (thread-safe) para um Array; no entanto, classes do .NET Framework com base no Array fornecer sua própria versão sincronizada da coleção usando o SyncRoot propriedade. This implementation does not provide a synchronized (thread safe) wrapper for an Array; however, .NET Framework classes based on Array provide their own synchronized version of the collection using the SyncRoot property. A enumeração por meio de uma coleção não é um procedimento thread-safe intrínseco. Enumerating through a collection is intrinsically not a thread-safe procedure. 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. Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. 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. To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.

Veja também