Array.Copy Método

Definição

Espaço de Nomes:
System
Assemblagens:
netstandard.dll, System.Runtime.dll
Assemblagem:
System.Runtime.dll
Assemblagem:
mscorlib.dll
Assemblagem:
netstandard.dll
Assemblagens:
mscorlib.dll, System.Runtime.dll

Copia uma variedade de elementos de um Array para o outro Array e realiza a tipagem e o boxing conforme necessário.

Sobrecargas

Name Description
Copy(Array, Int64, Array, Int64, Int64)

Copia um conjunto de elementos de um Array a partir do índice de origem especificado e cola-os noutro Array a partir do índice de destino especificado. O comprimento e os índices são especificados como inteiros de 64 bits.
Copy(Array, Int32, Array, Int32, Int32)

Copia um conjunto de elementos de um Array a partir do índice de origem especificado e cola-os noutro Array a partir do índice de destino especificado. O comprimento e os índices são especificados como inteiros de 32 bits.
Copy(Array, Array, Int32)

Copia uma série de elementos de um Array começando pelo primeiro elemento e cola-os noutro Array começando pelo primeiro elemento. O comprimento é especificado como um inteiro de 32 bits.
Copy(Array, Array, Int64)

Copia uma série de elementos de um Array começando pelo primeiro elemento e cola-os noutro Array começando pelo primeiro elemento. O comprimento é especificado como um inteiro de 64 bits.

Exemplos

O seguinte exemplo de código mostra como copiar de um Array de tipo Object para outro Array de tipo inteiro.

open System

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

 // Creates and initializes a new Array of type int.
let myIntArray = [| 1..5 |]

// Creates and initializes a new Array of type Object.
let myObjArray = Array.init 5 (fun i -> i + 26 :> obj)

// Displays the initial values of both arrays.
printfn "int array:"
printValues myIntArray 
printfn "Object array:"
printValues myObjArray

// Copies the first element from the int array to the Object array.
Array.Copy(myIntArray, myIntArray.GetLowerBound 0, myObjArray, myObjArray.GetLowerBound 0, 1)

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

// Displays the values of the modified arrays.
printfn "int array - Last two elements should now be the same as Object array:"
printValues myIntArray 
printfn "Object array - First element should now be the same as int array:"
printValues myObjArray


// This code produces the following output.
//     int array:
//         1    2    3    4    5
//     Object array:
//         26    27    28    29    30
//     int array - Last two elements should now be the same as Object array:
//         1    2    3    29    30
//     Object array - First element should now be the same as int array:
//         1    27    28    29    30

using System;
public class SamplesArray  {

   public static void Main()  {

      // Creates and initializes a new Array of type int.
      Array myIntArray=Array.CreateInstance( typeof(System.Int32), 5 );
      for ( int i = myIntArray.GetLowerBound(0); i <= myIntArray.GetUpperBound(0); i++ )
         myIntArray.SetValue( i+1, i );

      // Creates and initializes a new Array of type Object.
      Array myObjArray = Array.CreateInstance( typeof(System.Object), 5 );
      for ( int i = myObjArray.GetLowerBound(0); i <= myObjArray.GetUpperBound(0); i++ )
         myObjArray.SetValue( i+26, i );

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

      // Copies the first element from the int array to the Object array.
      Array.Copy( myIntArray, myIntArray.GetLowerBound(0), myObjArray, myObjArray.GetLowerBound(0), 1 );

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

      // Displays the values of the modified arrays.
      Console.WriteLine( "int array - Last two elements should now be the same as Object array:" );
      PrintValues( myIntArray );
      Console.WriteLine( "Object array - First element should now be the same as int array:" );
      PrintValues( myObjArray );
   }

   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.

int array:
    1    2    3    4    5
Object array:
    26    27    28    29    30
int array - Last two elements should now be the same as Object array:
    1    2    3    29    30
Object array - First element should now be the same as int array:
    1    27    28    29    30
*/

Public Class SamplesArray    
    
    Public Shared Sub Main()
        
        ' Creates and initializes a new Array of type Int32.
        Dim myIntArray As Array = _
           Array.CreateInstance(GetType(System.Int32), 5)
        Dim i As Integer
        For i = myIntArray.GetLowerBound(0) To myIntArray.GetUpperBound(0)
            myIntArray.SetValue(i + 1, i)
        Next i 
        ' Creates and initializes a new Array of type Object.
        Dim myObjArray As Array = _
           Array.CreateInstance(GetType(System.Object), 5)
        For i = myObjArray.GetLowerBound(0) To myObjArray.GetUpperBound(0)
            myObjArray.SetValue(i + 26, i)
        Next i 
        ' Displays the initial values of both arrays.
        Console.WriteLine("Int32 array:")
        PrintValues(myIntArray)
        Console.WriteLine("Object array:")
        PrintValues(myObjArray)
        
        ' Copies the first element from the Int32 array to the Object array.
        Array.Copy(myIntArray, myIntArray.GetLowerBound(0), myObjArray, _
           myObjArray.GetLowerBound(0), 1)
        
        ' Copies the last two elements from the Object array to the Int32 array.
        Array.Copy(myObjArray, myObjArray.GetUpperBound(0) - 1, myIntArray, _
           myIntArray.GetUpperBound(0) - 1, 2)
        
        ' Displays the values of the modified arrays.
        Console.WriteLine("Int32 array - Last two elements should now be " _
           + "the same as Object array:")
        PrintValues(myIntArray)
        Console.WriteLine("Object array - First element should now be the " _
           + "same as Int32 array:")
        PrintValues(myObjArray)
    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.
' 
' Int32 array:
'     1    2    3    4    5
' Object array:
'     26    27    28    29    30
' Int32 array - Last two elements should now be the same as Object array:
'     1    2    3    29    30
' Object array - First element should now be the same as Int32 array:
'     1    27    28    29    30

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

Origem:
Array.cs
Origem:
Array.cs
Origem:
Array.cs
Origem:
Array.cs
Origem:
Array.cs

Copia um conjunto de elementos de um Array a partir do índice de origem especificado e cola-os noutro Array a partir do índice de destino especificado. O comprimento e os índices são especificados como inteiros de 64 bits.

public:
 static void Copy(Array ^ sourceArray, long sourceIndex, Array ^ destinationArray, long destinationIndex, long length);
public static void Copy(Array sourceArray, long sourceIndex, Array destinationArray, long destinationIndex, long length);
static member Copy : Array * int64 * Array * int64 * int64 -> unit
Public Shared Sub Copy (sourceArray As Array, sourceIndex As Long, destinationArray As Array, destinationIndex As Long, length As Long)

Parâmetros

sourceArray
Array

O Array que contém os dados a copiar.

sourceIndex
Int64

Um inteiro de 64 bits que representa o índice em sourceArray onde começa a cópia.

destinationArray
Array

O Array que recebe os dados.

destinationIndex
Int64

Um inteiro de 64 bits que representa o índice em destinationArray onde começa o armazenamento.

length
Int64

Um inteiro de 64 bits que representa o número de elementos a copiar. O inteiro deve estar entre zero e Int32.MaxValue, inclusive.

Exceções

ArgumentNullException

sourceArray é null.

-ou-

destinationArray é null.

RankException

sourceArray e destinationArray têm patentes diferentes.

ArrayTypeMismatchException

sourceArray e destinationArray são de tipos incompatíveis.

InvalidCastException

Pelo menos um elemento em sourceArray não pode ser fundido para o tipo de destinationArray.

ArgumentOutOfRangeException

sourceIndex está fora do intervalo de índices válidos para o sourceArray.

-ou-

destinationIndex está fora do intervalo de índices válidos para o destinationArray.

-ou-

length é inferior a 0 ou superior a Int32.MaxValue.

ArgumentException

length é maior do que o número de elementos de sourceIndex até ao fim de sourceArray.

-ou-

length é maior do que o número de elementos de destinationIndex até ao fim de destinationArray.

Observações

Os sourceArray parâmetros e destinationArray devem ter o mesmo número de dimensões. Além disso, destinationArray deve já ter sido dimensionado e deve ter um número suficiente de elementos a partir da destinationIndex posição para acomodar os dados copiados.

Ao copiar entre arrays multidimensionais, o array comporta-se como um array longo unidimensional, onde as linhas (ou colunas) são conceitualmente dispostas ponta a ponta. Por exemplo, se um array tiver três linhas (ou colunas) com quatro elementos cada, copiar seis elementos do início do array copiaria os quatro elementos da primeira linha (ou coluna) e os dois primeiros elementos da segunda linha (ou coluna). Para começar a copiar a partir do segundo elemento da terceira linha (ou coluna), sourceIndex deve haver o limite superior da primeira linha (ou coluna) mais o comprimento da segunda linha (ou coluna) mais dois.

Se sourceArray e destinationArray se sobrepõem, este método comporta-se como se os valores originais de sourceArray tivessem sido preservados numa localização temporária antes destinationArray fosse sobrescrevido.

[C++]

Este método é equivalente à função memmovepadrão C/C++ , não memcpy.

Os arrays podem ser arrays do tipo referência ou arrays do tipo valor. É realizado o tipo de downcasting, conforme necessário.

  • Ao copiar de um array do tipo referência para um array do tipo de valor, cada elemento é desencaixado e depois copiado. Ao copiar de um array de tipos de valores para um array de tipo referência, cada elemento é encaixado e depois copiado.

  • Ao copiar de um array de tipo de referência ou de tipo de valor para um Object array, um Object é criado para guardar cada valor ou referência e depois copiado. Ao copiar de um Object array para um array de tipo de referência ou de tipo de valor e a atribuição não é possível, um InvalidCastException é lançado.

  • Se sourceArray e destinationArray forem ambos arrays de tipo de referência ou ambos forem arrays do tipo Object, realiza-se uma cópia superficial. Uma cópia superficial de an Array é uma nova Array que contém referências aos mesmos elementos do original Array. Os próprios elementos ou qualquer coisa referenciada pelos elementos não são copiados. Em contraste, uma cópia profunda de um Array copia os elementos e tudo o que é referido direta ou indiretamente pelos elementos.

An ArrayTypeMismatchException é lançado se os arrays forem de tipos incompatíveis. A compatibilidade de tipos é definida da seguinte forma:

  • Um tipo é compatível consigo próprio.

  • Um tipo de valor é compatível com Object e com um tipo de interface implementado por esse tipo de valor. Um tipo de valor é considerado ligado a uma interface apenas se implementar essa interface diretamente. Os tipos desconectados não são compatíveis.

  • Dois tipos de valores intrínsecos (pré-definidos) são compatíveis se copiar do tipo de origem para o tipo de destino for uma conversão de alargamento. Uma conversão alargada nunca perde informação, enquanto uma conversão estreita pode perder informação. Por exemplo, converter um inteiro assinado de 32 bits para um inteiro assinado de 64 bits é uma conversão de alargamento, e converter um inteiro com sinal de 64 bits para um inteiro com sinal de 32 bits é uma conversão de estreito. Para mais informações sobre conversões, consulte Convert.

  • Um tipo de valor não intrínseco (definido pelo utilizador) é compatível apenas consigo próprio.

  • As enumerações têm uma conversão implícita para Enum e para o seu tipo subjacente.

Se cada elemento em sourceArray requer um downcast (por exemplo, de uma classe base para uma classe derivada ou de uma interface para um objeto) e um ou mais elementos não podem ser castados para o tipo correspondente em destinationArray, e InvalidCastException é lançado.

Se este método lançar uma exceção durante a cópia, o estado de destinationArray é indefinido.

Este método é uma operação O(n), onde n é length.

Ver também

Aplica-se a

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

Origem:
Array.cs
Origem:
Array.cs
Origem:
Array.CoreCLR.cs
Origem:
Array.cs
Origem:
Array.cs

Copia um conjunto de elementos de um Array a partir do índice de origem especificado e cola-os noutro Array a partir do índice de destino especificado. O comprimento e os índices são especificados como inteiros de 32 bits.

public:
 static void Copy(Array ^ sourceArray, int sourceIndex, Array ^ destinationArray, int destinationIndex, int length);
public static void Copy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length);
static member Copy : Array * int * Array * int * int -> unit
Public Shared Sub Copy (sourceArray As Array, sourceIndex As Integer, destinationArray As Array, destinationIndex As Integer, length As Integer)

Parâmetros

sourceArray
Array

O Array que contém os dados a copiar.

sourceIndex
Int32

Um inteiro de 32 bits que representa o índice em sourceArray onde a cópia começa.

destinationArray
Array

O Array que recebe os dados.

destinationIndex
Int32

Um inteiro de 32 bits que representa o índice em destinationArray onde começa o armazenamento.

length
Int32

Um inteiro de 32 bits que representa o número de elementos a copiar.

Exceções

ArgumentNullException

sourceArray é null.

-ou-

destinationArray é null.

RankException

sourceArray e destinationArray têm patentes diferentes.

ArrayTypeMismatchException

sourceArray e destinationArray são de tipos incompatíveis.

InvalidCastException

Pelo menos um elemento em sourceArray não pode ser fundido para o tipo de destinationArray.

ArgumentOutOfRangeException

sourceIndex é menor que o limite inferior da primeira dimensão de sourceArray.

-ou-

destinationIndex é menor que o limite inferior da primeira dimensão de destinationArray.

-ou-

length é inferior a zero.

ArgumentException

length é maior do que o número de elementos de sourceIndex até ao fim de sourceArray.

-ou-

length é maior do que o número de elementos de destinationIndex até ao fim de destinationArray.

Observações

Os sourceArray parâmetros e destinationArray devem ter o mesmo número de dimensões. Além disso, destinationArray deve já ter sido dimensionado e deve ter um número suficiente de elementos a partir da destinationIndex posição para acomodar os dados copiados.

Ao copiar entre arrays multidimensionais, o array comporta-se como um array longo unidimensional, onde as linhas (ou colunas) são conceitualmente dispostas ponta a ponta. Por exemplo, se um array tiver três linhas (ou colunas) com quatro elementos cada, copiar seis elementos do início do array copiaria os quatro elementos da primeira linha (ou coluna) e os dois primeiros elementos da segunda linha (ou coluna). Para começar a copiar a partir do segundo elemento da terceira linha (ou coluna), sourceIndex deve haver o limite superior da primeira linha (ou coluna) mais o comprimento da segunda linha (ou coluna) mais dois.

Se sourceArray e destinationArray se sobrepõem, este método comporta-se como se os valores originais de sourceArray tivessem sido preservados numa localização temporária antes destinationArray fosse sobrescrevido.

[C++]

Este método é equivalente à função memmovepadrão C/C++ , não memcpy.

Os arrays podem ser arrays do tipo referência ou arrays do tipo valor. É realizado o tipo de downcasting, conforme necessário.

  • Ao copiar de um array do tipo referência para um array do tipo de valor, cada elemento é desencaixado e depois copiado. Ao copiar de um array de tipos de valores para um array de tipo referência, cada elemento é encaixado e depois copiado.

  • Ao copiar de um array de tipo de referência ou de tipo de valor para um Object array, um Object é criado para guardar cada valor ou referência e depois copiado. Ao copiar de um Object array para um array de tipo de referência ou de tipo de valor e a atribuição não é possível, um InvalidCastException é lançado.

  • Se sourceArray e destinationArray forem ambos arrays de tipo de referência ou ambos forem arrays do tipo Object, realiza-se uma cópia superficial. Uma cópia superficial de an Array é uma nova Array que contém referências aos mesmos elementos do original Array. Os próprios elementos ou qualquer coisa referenciada pelos elementos não são copiados. Em contraste, uma cópia profunda de um Array copia os elementos e tudo o que é referido direta ou indiretamente pelos elementos.

An ArrayTypeMismatchException é lançado se os arrays forem de tipos incompatíveis. A compatibilidade de tipos é definida da seguinte forma:

  • Um tipo é compatível consigo próprio.

  • Um tipo de valor é compatível com Object e com um tipo de interface implementado por esse tipo de valor. Um tipo de valor é considerado ligado a uma interface apenas se implementar essa interface diretamente. Os tipos desconectados não são compatíveis.

  • Dois tipos de valores intrínsecos (pré-definidos) são compatíveis se copiar do tipo de origem para o tipo de destino for uma conversão de alargamento. Uma conversão alargada nunca perde informação, enquanto uma conversão estreita pode perder informação. Por exemplo, converter um inteiro assinado de 32 bits para um inteiro assinado de 64 bits é uma conversão de alargamento, e converter um inteiro com sinal de 64 bits para um inteiro com sinal de 32 bits é uma conversão de estreito. Para mais informações sobre conversões, consulte Convert.

  • Um tipo de valor não intrínseco (definido pelo utilizador) é compatível apenas consigo próprio.

  • As enumerações têm uma conversão implícita para Enum e para o seu tipo subjacente.

Se cada elemento em sourceArray requer um downcast (por exemplo, de uma classe base para uma classe derivada ou de uma interface para um objeto) e um ou mais elementos não podem ser castados para o tipo correspondente em destinationArray, e InvalidCastException é lançado.

Se este método lançar uma exceção durante a cópia, o estado de destinationArray é indefinido.

Este método é uma operação O(n), onde n é length.

Ver também

Aplica-se a

Copy(Array, Array, Int32)

Origem:
Array.cs
Origem:
Array.cs
Origem:
Array.CoreCLR.cs
Origem:
Array.cs
Origem:
Array.cs

Copia uma série de elementos de um Array começando pelo primeiro elemento e cola-os noutro Array começando pelo primeiro elemento. O comprimento é especificado como um inteiro de 32 bits.

public:
 static void Copy(Array ^ sourceArray, Array ^ destinationArray, int length);
public static void Copy(Array sourceArray, Array destinationArray, int length);
static member Copy : Array * Array * int -> unit
Public Shared Sub Copy (sourceArray As Array, destinationArray As Array, length As Integer)

Parâmetros

sourceArray
Array

O Array que contém os dados a copiar.

destinationArray
Array

O Array que recebe os dados.

length
Int32

Um inteiro de 32 bits que representa o número de elementos a copiar.

Exceções

ArgumentNullException

sourceArray é null.

-ou-

destinationArray é null.

RankException

sourceArray e destinationArray têm patentes diferentes.

ArrayTypeMismatchException

sourceArray e destinationArray são de tipos incompatíveis.

InvalidCastException

Pelo menos um elemento em sourceArray não pode ser fundido para o tipo de destinationArray.

ArgumentOutOfRangeException

length é inferior a zero.

ArgumentException

length é maior do que o número de elementos em sourceArray.

-ou-

length é maior do que o número de elementos em destinationArray.

Observações

Os sourceArray parâmetros e destinationArray devem ter o mesmo número de dimensões. Além disso, destinationArray deve já ter sido dimensionado e deve ter um número suficiente de elementos para acomodar os dados copiados.

Ao copiar entre arrays multidimensionais, o array comporta-se como um array longo unidimensional, onde as linhas (ou colunas) são conceptualmente dispostas lado a lado. Por exemplo, se um array tiver três linhas (ou colunas) com quatro elementos cada, copiar seis elementos do início do array copiaria os quatro elementos da primeira linha (ou coluna) e os dois primeiros elementos da segunda linha (ou coluna).

Se sourceArray e destinationArray se sobrepõem, este método comporta-se como se os valores originais de sourceArray tivessem sido preservados numa localização temporária antes destinationArray fosse sobrescrevido.

[C++]

Este método é equivalente à função memmovepadrão C/C++ , não memcpy.

Os arrays podem ser arrays do tipo referência ou arrays do tipo valor. É realizado o tipo de downcasting, conforme necessário.

  • Ao copiar de um array do tipo referência para um array do tipo de valor, cada elemento é desencaixado e depois copiado. Ao copiar de um array de tipos de valores para um array de tipo referência, cada elemento é encaixado e depois copiado.

  • Ao copiar de um array de tipo de referência ou de tipo de valor para um Object array, um Object é criado para guardar cada valor ou referência e depois copiado. Ao copiar de um Object array para um array de tipo de referência ou de tipo de valor e a atribuição não é possível, um InvalidCastException é lançado.

  • Se sourceArray e destinationArray forem ambos arrays de tipo de referência ou ambos forem arrays do tipo Object, realiza-se uma cópia superficial. Uma cópia superficial de an Array é uma nova Array que contém referências aos mesmos elementos do original Array. Os próprios elementos ou qualquer coisa referenciada pelos elementos não são copiados. Em contraste, uma cópia profunda de um Array copia os elementos e tudo o que é referido direta ou indiretamente pelos elementos.

An ArrayTypeMismatchException é lançado se os arrays forem de tipos incompatíveis. A compatibilidade de tipos é definida da seguinte forma:

  • Um tipo é compatível consigo próprio.

  • Um tipo de valor é compatível com Object e com um tipo de interface implementado por esse tipo de valor. Um tipo de valor é considerado ligado a uma interface apenas se implementar essa interface diretamente. Os tipos desconectados não são compatíveis.

  • Dois tipos de valores intrínsecos (pré-definidos) são compatíveis se copiar do tipo de origem para o tipo de destino for uma conversão de alargamento. Uma conversão alargada nunca perde informação, enquanto uma conversão estreita pode perder informação. Por exemplo, converter um inteiro assinado de 32 bits para um inteiro assinado de 64 bits é uma conversão de alargamento, e converter um inteiro com sinal de 64 bits para um inteiro com sinal de 32 bits é uma conversão de estreito. Para mais informações sobre conversões, consulte Convert.

  • Um tipo de valor não intrínseco (definido pelo utilizador) é compatível apenas consigo próprio.

  • As enumerações têm uma conversão implícita para Enum e para o seu tipo subjacente.

Se cada elemento em sourceArray requer um downcast (por exemplo, de uma classe base para uma classe derivada ou de uma interface para um objeto) e um ou mais elementos não podem ser castados para o tipo correspondente em destinationArray, e InvalidCastException é lançado.

Se este método lançar uma exceção durante a cópia, o estado de destinationArray é indefinido.

Este método é uma operação O(n), onde n é length.

Ver também

Aplica-se a

Copy(Array, Array, Int64)

Origem:
Array.cs
Origem:
Array.cs
Origem:
Array.cs
Origem:
Array.cs
Origem:
Array.cs

Copia uma série de elementos de um Array começando pelo primeiro elemento e cola-os noutro Array começando pelo primeiro elemento. O comprimento é especificado como um inteiro de 64 bits.

public:
 static void Copy(Array ^ sourceArray, Array ^ destinationArray, long length);
public static void Copy(Array sourceArray, Array destinationArray, long length);
static member Copy : Array * Array * int64 -> unit
Public Shared Sub Copy (sourceArray As Array, destinationArray As Array, length As Long)

Parâmetros

sourceArray
Array

O Array que contém os dados a copiar.

destinationArray
Array

O Array que recebe os dados.

length
Int64

Um inteiro de 64 bits que representa o número de elementos a copiar. O inteiro deve estar entre zero e Int32.MaxValue, inclusive.

Exceções

ArgumentNullException

sourceArray é null.

-ou-

destinationArray é null.

RankException

sourceArray e destinationArray têm patentes diferentes.

ArrayTypeMismatchException

sourceArray e destinationArray são de tipos incompatíveis.

InvalidCastException

Pelo menos um elemento em sourceArray não pode ser fundido para o tipo de destinationArray.

ArgumentOutOfRangeException

length é inferior a 0 ou superior a Int32.MaxValue.

ArgumentException

length é maior do que o número de elementos em sourceArray.

-ou-

length é maior do que o número de elementos em destinationArray.

Observações

Os sourceArray parâmetros e destinationArray devem ter o mesmo número de dimensões. Além disso, destinationArray deve já ter sido dimensionado e deve ter um número suficiente de elementos para acomodar os dados copiados.

Ao copiar entre arrays multidimensionais, o array comporta-se como um array longo unidimensional, onde as linhas (ou colunas) são conceptualmente dispostas lado a lado. Por exemplo, se um array tiver três linhas (ou colunas) com quatro elementos cada, copiar seis elementos do início do array copiaria os quatro elementos da primeira linha (ou coluna) e os dois primeiros elementos da segunda linha (ou coluna).

Se sourceArray e destinationArray se sobrepõem, este método comporta-se como se os valores originais de sourceArray tivessem sido preservados numa localização temporária antes destinationArray fosse sobrescrevido.

[C++]

Este método é equivalente à função memmovepadrão C/C++ , não memcpy.

Os arrays podem ser arrays do tipo referência ou arrays do tipo valor. É realizado o tipo de downcasting, conforme necessário.

  • Ao copiar de um array do tipo referência para um array do tipo de valor, cada elemento é desencaixado e depois copiado. Ao copiar de um array de tipos de valores para um array de tipo referência, cada elemento é encaixado e depois copiado.

  • Ao copiar de um array de tipo de referência ou de tipo de valor para um Object array, um Object é criado para guardar cada valor ou referência e depois copiado. Ao copiar de um Object array para um array de tipo de referência ou de tipo de valor e a atribuição não é possível, um InvalidCastException é lançado.

  • Se sourceArray e destinationArray forem ambos arrays de tipo de referência ou ambos forem arrays do tipo Object, realiza-se uma cópia superficial. Uma cópia superficial de an Array é uma nova Array que contém referências aos mesmos elementos do original Array. Os próprios elementos ou qualquer coisa referenciada pelos elementos não são copiados. Em contraste, uma cópia profunda de um Array copia os elementos e tudo o que é referido direta ou indiretamente pelos elementos.

An ArrayTypeMismatchException é lançado se os arrays forem de tipos incompatíveis. A compatibilidade de tipos é definida da seguinte forma:

  • Um tipo é compatível consigo próprio.

  • Um tipo de valor é compatível com Object e com um tipo de interface implementado por esse tipo de valor. Um tipo de valor é considerado ligado a uma interface apenas se implementar essa interface diretamente. Os tipos desconectados não são compatíveis.

  • Dois tipos de valores intrínsecos (pré-definidos) são compatíveis se copiar do tipo de origem para o tipo de destino for uma conversão de alargamento. Uma conversão alargada nunca perde informação, enquanto uma conversão estreita pode perder informação. Por exemplo, converter um inteiro assinado de 32 bits para um inteiro assinado de 64 bits é uma conversão de alargamento, e converter um inteiro com sinal de 64 bits para um inteiro com sinal de 32 bits é uma conversão de estreito. Para mais informações sobre conversões, consulte Convert.

  • Um tipo de valor não intrínseco (definido pelo utilizador) é compatível apenas consigo próprio.

  • As enumerações têm uma conversão implícita para Enum e para o seu tipo subjacente.

Se cada elemento em sourceArray requer um downcast (por exemplo, de uma classe base para uma classe derivada ou de uma interface para um objeto) e um ou mais elementos não podem ser castados para o tipo correspondente em destinationArray, e InvalidCastException é lançado.

Se este método lançar uma exceção durante a cópia, o estado de destinationArray é indefinido.

Este método é uma operação O(n), onde n é length.

Ver também

Aplica-se a