Array.Copy Metoda

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

Zkopíruje rozsah prvků v jednom Array do druhého Array a podle potřeby provádí přetypování a balení typu.

Přetížení

Copy(Array, Int64, Array, Int64, Int64)	Zkopíruje rozsah prvků od Array zadaného zdrojového indexu a vloží je do jiného Array počínaje zadaným cílovým indexem. Délka a indexy jsou zadané jako 64bitová celá čísla.
Copy(Array, Int32, Array, Int32, Int32)	Zkopíruje rozsah prvků od Array zadaného zdrojového indexu a vloží je do jiného Array počínaje zadaným cílovým indexem. Délka a indexy jsou zadány jako 32bitová celá čísla.
Copy(Array, Array, Int32)	Zkopíruje rozsah elementů od Array prvního elementu a vloží je do jiného Array od prvního elementu. Délka je určena jako 32bitové celé číslo.
Copy(Array, Array, Int64)	Zkopíruje rozsah elementů od Array prvního elementu a vloží je do jiného Array od prvního elementu. Délka je zadána jako 64bitové celé číslo.

Příklady

Následující příklad kódu ukazuje, jak kopírovat z jednoho Array typu Object do jiného Array typu typu integer.

using namespace System;
void PrintValues( Array^ myArr );
void main()
{
   
   // Creates and initializes a new Array instance of type Int32.
   Array^ myIntArray = Array::CreateInstance( Type::GetType(  "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 instance of type Object.
   Array^ myObjArray = Array::CreateInstance( Type::GetType(  "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(  "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 );
}

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

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)

Zdroj:: Array.cs

Zdroj:: Array.cs

Zdroj:: Array.cs

Zkopíruje rozsah prvků od Array zadaného zdrojového indexu a vloží je do jiného Array počínaje zadaným cílovým indexem. Délka a indexy jsou zadané jako 64bitová celá čísla.

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)

Parametry

sourceArray: Array

Obsahuje Array data, která chcete zkopírovat.

sourceIndex: Int64

64bitové celé číslo, které představuje index ve sourceArray kterém začíná kopírování.

destinationArray: Array

Ten Array , který přijímá data.

destinationIndex: Int64

64bitové celé číslo, které představuje index ve destinationArray kterém začíná ukládání.

length: Int64

64bitové celé číslo, které představuje počet prvků ke zkopírování. Celé číslo musí být mezi nulou a Int32.MaxValue včetně.

Výjimky

ArgumentNullException

sourceArray je null.

-nebo-

destinationArray je null.

RankException

sourceArray a destinationArray mají různé hodnosti.

ArrayTypeMismatchException

sourceArray a destinationArray jsou nekompatibilních typů.

InvalidCastException

Nejméně jeden prvek v sourceArray souboru nelze přetypovat na typ destinationArray.

ArgumentOutOfRangeException

sourceIndex je mimo rozsah platných indexů pro sourceArray.

-nebo-

destinationIndex je mimo rozsah platných indexů pro destinationArray.

-nebo-

length je menší než 0 nebo větší než Int32.MaxValue.

ArgumentException

lengthje větší než počet prvků od sourceIndex do konce .sourceArray

-nebo-

lengthje větší než počet prvků od destinationIndex do konce .destinationArray

Poznámky

Parametry sourceArray a destinationArray musí mít stejný počet dimenzí. Kromě toho destinationArray musí být již dimenzovány a musí mít dostatečný počet prvků počínaje destinationIndex pozicí, aby bylo možné pojmout kopírovaná data.

Při kopírování mezi multidimenzionálními poli se matice chová jako dlouhé jednorozměrné pole, kde jsou řádky (nebo sloupce) koncepčně položeny od konce do konce. Obsahuje-li pole například tři řádky (nebo sloupce) po čtyřech prvcích, při kopírování šesti prvků od začátku pole budou zkopírovány všechny čtyři prvky z prvního řádku (nebo sloupce) a první dva prvky z druhého řádku (nebo sloupce). Chcete-li začít kopírovat od druhého prvku třetího řádku (nebo sloupce), sourceIndex musí být horní mez prvního řádku (nebo sloupce) plus délka druhého řádku (nebo sloupce) plus dva.

Pokud sourceArray a destinationArray překrývají se, tato metoda se chová, jako by původní hodnoty sourceArray byly zachovány v dočasném umístění před destinationArray přepsání.

[C++]

Tato metoda je ekvivalentní standardní funkci memmoveC/C++ , nikoli memcpy.

Pole mohou být odkazového nebo hodnotového typu. Podle potřeby je provedeno přetypování na nižší typ.

Při kopírování z pole typu odkazu do pole typu hodnoty je každý prvek nejprve vybalen a poté zkopírován. Při kopírování z pole typu hodnoty do pole typu odkazu je každý prvek nejprve zabalen a poté zkopírován.
Při kopírování z pole typu odkazu nebo hodnotového typu do Object pole se vytvoří objekt, který Object bude obsahovat každou hodnotu nebo odkaz, a pak se zkopíruje. Při kopírování z Object pole do pole typu odkazu nebo typu hodnoty a přiřazení není možné, InvalidCastException je vyvolán příkaz .
destinationArray Jsou-li sourceArray pole referenčního typu a nebo jsou-li obě pole typu Object, provede se mělká kopie. Mělká kopie objektu Array je nová Array , která obsahuje odkazy na stejné prvky jako původní Array. Nekopírují se samotné prvky ani objekty, na které odkazují. Naproti tomu hloubková kopie zkopíruje Array prvky a vše, na co prvky přímo nebo nepřímo odkazují.

Vyvolá ArrayTypeMismatchException se, pokud jsou pole nekompatibilních typů. Kompatibilita typů je definována takto:

Typ je kompatibilní sám se sebou.
Typ hodnoty je kompatibilní s Object typem rozhraní implementovaným tímto typem hodnoty a s tímto typem. Typ hodnoty je považován za připojený k rozhraní jen tehdy, když toto rozhraní přímo implementuje. Odpojené typy nejsou kompatibilní.
Dva vnitřní (předdefinované) typy hodnot jsou kompatibilní, pokud platí, že kopírování ze zdrojového do cílového typu je rozšiřující převod. Při rozšiřujícím převodu nikdy nedochází ke ztrátě informací, zatímco u zužujícího převodu k ní dojít může. Převod 32bitového celého čísla se znaménkem na 64bitové celé číslo se znaménkem je rozšiřující; převod 64bitového celého čísla se znaménkem na 32bitové celé číslo se znaménkem je zužující. Další informace o převodech najdete v tématu Convert.
Jiný než vnitřní typ hodnoty (definovaný uživatelem) je kompatibilní pouze sám se sebou.
Výčty mají implicitní převod na Enum a na svůj základní typ.

Pokud každý prvek v sourceArray vyžaduje downcast (například ze základní třídy na odvozenou třídu nebo z rozhraní na objekt) a jeden nebo více prvků nelze přetypovat na odpovídající typ v destinationArray, InvalidCastException je vyvolán.

Pokud tato metoda vyvolá výjimku při kopírování, stav destinationArray není definován.

Tato metoda je operace O(n), kde n je length.

Viz také

Platí pro

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

Zdroj:: Array.CoreCLR.cs

Zdroj:: Array.cs

Zdroj:: Array.cs

Zkopíruje rozsah prvků od Array zadaného zdrojového indexu a vloží je do jiného Array počínaje zadaným cílovým indexem. Délka a indexy jsou zadány jako 32bitová celá čísla.

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)

Parametry

sourceArray: Array

Obsahuje Array data, která chcete zkopírovat.

sourceIndex: Int32

32bitové celé číslo, které představuje index ve sourceArray kterém začíná kopírování.

destinationArray: Array

Ten Array , který přijímá data.

destinationIndex: Int32

32bitové celé číslo, které představuje index ve destinationArray kterém začíná ukládání.

length: Int32

32bitové celé číslo, které představuje počet prvků ke kopírování.

Výjimky

ArgumentNullException

sourceArray je null.

-nebo-

destinationArray je null.

RankException

sourceArray a destinationArray mají různé hodnosti.

ArrayTypeMismatchException

sourceArray a destinationArray jsou nekompatibilních typů.

InvalidCastException

Nejméně jeden prvek v sourceArray souboru nelze přetypovat na typ destinationArray.

ArgumentOutOfRangeException

sourceIndex je menší než dolní mez první dimenze sourceArray.

-nebo-

destinationIndex je menší než dolní mez první dimenze destinationArray.

-nebo-

Hodnota length je menší než nula.

ArgumentException

lengthje větší než počet prvků od sourceIndex do konce .sourceArray

-nebo-

lengthje větší než počet prvků od destinationIndex do konce .destinationArray

Poznámky

[C++]

Tato metoda je ekvivalentní standardní funkci memmoveC/C++ , nikoli memcpy.

Pole mohou být odkazového nebo hodnotového typu. Podle potřeby je provedeno přetypování na nižší typ.

Při kopírování z pole typu odkazu do pole typu hodnoty je každý prvek nejprve vybalen a poté zkopírován. Při kopírování z pole typu hodnoty do pole typu odkazu je každý prvek nejprve zabalen a poté zkopírován.
Při kopírování z pole typu odkazu nebo hodnotového typu do Object pole se vytvoří objekt, který Object bude obsahovat každou hodnotu nebo odkaz, a pak se zkopíruje. Při kopírování z Object pole do pole typu odkazu nebo typu hodnoty a přiřazení není možné, InvalidCastException je vyvolán příkaz .
destinationArray Jsou-li sourceArray pole referenčního typu a nebo jsou-li obě pole typu Object, provede se mělká kopie. Mělká kopie objektu Array je nová Array , která obsahuje odkazy na stejné prvky jako původní Array. Nekopírují se samotné prvky ani objekty, na které odkazují. Naproti tomu hloubková kopie zkopíruje Array prvky a vše, na co prvky přímo nebo nepřímo odkazují.

Vyvolá ArrayTypeMismatchException se, pokud jsou pole nekompatibilních typů. Kompatibilita typů je definována takto:

Typ je kompatibilní sám se sebou.
Typ hodnoty je kompatibilní s Object typem rozhraní implementovaným tímto typem hodnoty a s tímto typem. Typ hodnoty je považován za připojený k rozhraní jen tehdy, když toto rozhraní přímo implementuje. Odpojené typy nejsou kompatibilní.
Dva vnitřní (předdefinované) typy hodnot jsou kompatibilní, pokud platí, že kopírování ze zdrojového do cílového typu je rozšiřující převod. Při rozšiřujícím převodu nikdy nedochází ke ztrátě informací, zatímco u zužujícího převodu k ní dojít může. Převod 32bitového celého čísla se znaménkem na 64bitové celé číslo se znaménkem je rozšiřující; převod 64bitového celého čísla se znaménkem na 32bitové celé číslo se znaménkem je zužující. Další informace o převodech najdete v tématu Convert.
Jiný než vnitřní typ hodnoty (definovaný uživatelem) je kompatibilní pouze sám se sebou.
Výčty mají implicitní převod na Enum a na svůj základní typ.

Pokud tato metoda vyvolá výjimku při kopírování, stav destinationArray není definován.

Tato metoda je operace O(n), kde n je length.

Viz také

Platí pro

Copy(Array, Array, Int32)

Zdroj:: Array.CoreCLR.cs

Zdroj:: Array.cs

Zdroj:: Array.cs

Zkopíruje rozsah elementů od Array prvního elementu a vloží je do jiného Array od prvního elementu. Délka je určena jako 32bitové celé číslo.

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)

Parametry

sourceArray: Array

Obsahuje Array data, která chcete zkopírovat.

destinationArray: Array

Ten Array , který přijímá data.

length: Int32

32bitové celé číslo, které představuje počet prvků ke kopírování.

Výjimky

ArgumentNullException

sourceArray je null.

-nebo-

destinationArray je null.

RankException

sourceArray a destinationArray mají různé hodnosti.

ArrayTypeMismatchException

sourceArray a destinationArray jsou nekompatibilních typů.

InvalidCastException

Nejméně jeden prvek v sourceArray souboru nelze přetypovat na typ destinationArray.

ArgumentOutOfRangeException

Hodnota length je menší než nula.

ArgumentException

length je větší než počet prvků v sourceArraysouboru .

-nebo-

length je větší než počet prvků v destinationArraysouboru .

Poznámky

Parametry sourceArray a destinationArray musí mít stejný počet dimenzí. Kromě toho destinationArray musí být již dimenzovány a musí mít dostatečný počet prvků, aby bylo možné pojmout zkopírovaná data.

Při kopírování mezi multidimenzionálními poli se matice chová jako dlouhé jednorozměrné pole, kde jsou řádky (nebo sloupce) koncepčně položeny. Obsahuje-li pole například tři řádky (nebo sloupce) po čtyřech prvcích, při kopírování šesti prvků od začátku pole budou zkopírovány všechny čtyři prvky z prvního řádku (nebo sloupce) a první dva prvky z druhého řádku (nebo sloupce).

[C++]

Tato metoda je ekvivalentní standardní funkci memmoveC/C++ , nikoli memcpy.

Pole mohou být odkazového nebo hodnotového typu. Podle potřeby je provedeno přetypování na nižší typ.

Při kopírování z pole typu odkazu do pole typu hodnoty je každý prvek nejprve vybalen a poté zkopírován. Při kopírování z pole typu hodnoty do pole typu odkazu je každý prvek nejprve zabalen a poté zkopírován.
Při kopírování z pole typu odkazu nebo hodnotového typu do Object pole se vytvoří objekt, který Object bude obsahovat každou hodnotu nebo odkaz, a pak se zkopíruje. Při kopírování z Object pole do pole typu odkazu nebo typu hodnoty a přiřazení není možné, InvalidCastException je vyvolán příkaz .
destinationArray Jsou-li sourceArray pole referenčního typu a nebo jsou-li obě pole typu Object, provede se mělká kopie. Mělká kopie objektu Array je nová Array , která obsahuje odkazy na stejné prvky jako původní Array. Nekopírují se samotné prvky ani objekty, na které odkazují. Naproti tomu hloubková kopie zkopíruje Array prvky a vše, na co prvky přímo nebo nepřímo odkazují.

Vyvolá ArrayTypeMismatchException se, pokud jsou pole nekompatibilních typů. Kompatibilita typů je definována takto:

Typ je kompatibilní sám se sebou.
Typ hodnoty je kompatibilní s Object typem rozhraní implementovaným tímto typem hodnoty a s tímto typem. Typ hodnoty je považován za připojený k rozhraní jen tehdy, když toto rozhraní přímo implementuje. Odpojené typy nejsou kompatibilní.
Dva vnitřní (předdefinované) typy hodnot jsou kompatibilní, pokud platí, že kopírování ze zdrojového do cílového typu je rozšiřující převod. Při rozšiřujícím převodu nikdy nedochází ke ztrátě informací, zatímco u zužujícího převodu k ní dojít může. Převod 32bitového celého čísla se znaménkem na 64bitové celé číslo se znaménkem je rozšiřující; převod 64bitového celého čísla se znaménkem na 32bitové celé číslo se znaménkem je zužující. Další informace o převodech najdete v tématu Convert.
Jiný než vnitřní typ hodnoty (definovaný uživatelem) je kompatibilní pouze sám se sebou.
Výčty mají implicitní převod na Enum a na svůj základní typ.

Pokud tato metoda vyvolá výjimku při kopírování, stav destinationArray není definován.

Tato metoda je operace O(n), kde n je length.

Viz také

Platí pro

Copy(Array, Array, Int64)

Zdroj:: Array.cs

Zdroj:: Array.cs

Zdroj:: Array.cs

Zkopíruje rozsah elementů od Array prvního elementu a vloží je do jiného Array od prvního elementu. Délka je zadána jako 64bitové celé číslo.

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)

Parametry

sourceArray: Array

Obsahuje Array data, která chcete zkopírovat.

destinationArray: Array

Ten Array , který přijímá data.

length: Int64

64bitové celé číslo, které představuje počet prvků ke zkopírování. Celé číslo musí být mezi nulou a Int32.MaxValue včetně.

Výjimky

ArgumentNullException

sourceArray je null.

-nebo-

destinationArray je null.

RankException

sourceArray a destinationArray mají různé hodnosti.

ArrayTypeMismatchException

sourceArray a destinationArray jsou nekompatibilních typů.

InvalidCastException

Nejméně jeden prvek v sourceArray souboru nelze přetypovat na typ destinationArray.

ArgumentOutOfRangeException

length je menší než 0 nebo větší než Int32.MaxValue.

ArgumentException

length je větší než počet prvků v sourceArraysouboru .

-nebo-

length je větší než počet prvků v destinationArraysouboru .

Poznámky

[C++]

Tato metoda je ekvivalentní standardní funkci memmoveC/C++ , nikoli memcpy.

Pole mohou být odkazového nebo hodnotového typu. Podle potřeby je provedeno přetypování na nižší typ.

Při kopírování z pole typu odkazu do pole typu hodnoty je každý prvek nejprve vybalen a poté zkopírován. Při kopírování z pole typu hodnoty do pole typu odkazu je každý prvek nejprve zabalen a poté zkopírován.
Při kopírování z pole typu odkazu nebo hodnotového typu do Object pole se vytvoří objekt, který Object bude obsahovat každou hodnotu nebo odkaz, a pak se zkopíruje. Při kopírování z Object pole do pole typu odkazu nebo typu hodnoty a přiřazení není možné, InvalidCastException je vyvolán příkaz .
destinationArray Jsou-li sourceArray pole referenčního typu a nebo jsou-li obě pole typu Object, provede se mělká kopie. Mělká kopie objektu Array je nová Array , která obsahuje odkazy na stejné prvky jako původní Array. Nekopírují se samotné prvky ani objekty, na které odkazují. Naproti tomu hloubková kopie zkopíruje Array prvky a vše, na co prvky přímo nebo nepřímo odkazují.

Vyvolá ArrayTypeMismatchException se, pokud jsou pole nekompatibilních typů. Kompatibilita typů je definována takto:

Typ je kompatibilní sám se sebou.
Typ hodnoty je kompatibilní s Object typem rozhraní implementovaným tímto typem hodnoty a s tímto typem. Typ hodnoty je považován za připojený k rozhraní jen tehdy, když toto rozhraní přímo implementuje. Odpojené typy nejsou kompatibilní.
Dva vnitřní (předdefinované) typy hodnot jsou kompatibilní, pokud platí, že kopírování ze zdrojového do cílového typu je rozšiřující převod. Při rozšiřujícím převodu nikdy nedochází ke ztrátě informací, zatímco u zužujícího převodu k ní dojít může. Převod 32bitového celého čísla se znaménkem na 64bitové celé číslo se znaménkem je rozšiřující; převod 64bitového celého čísla se znaménkem na 32bitové celé číslo se znaménkem je zužující. Další informace o převodech najdete v tématu Convert.
Jiný než vnitřní typ hodnoty (definovaný uživatelem) je kompatibilní pouze sám se sebou.
Výčty mají implicitní převod na Enum a na svůj základní typ.

Pokud tato metoda vyvolá výjimku při kopírování, stav destinationArray není definován.

Tato metoda je operace O(n), kde n je length.

Viz také

Platí pro

Array.Copy Metoda

Definice

Přetížení

Příklady

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

Parametry

Výjimky

Poznámky

Viz také

Platí pro

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

Parametry

Výjimky

Poznámky

Viz také

Platí pro

Copy(Array, Array, Int32)

Parametry

Výjimky

Poznámky

Viz také

Platí pro

Copy(Array, Array, Int64)

Parametry

Výjimky

Poznámky

Viz také

Platí pro

Váš názor

Další materiály