Marshal.Copy Metode

Definisi

Ruang nama:

System.Runtime.InteropServices

Rakitan:

System.Runtime.InteropServices.dll

Menyalin data dari array terkelola ke penunjuk memori yang tidak dikelola, atau dari penunjuk memori yang tidak dikelola ke array terkelola.

Overload

Copy(Single[], Int32, IntPtr, Int32)	Menyalin data dari array angka floating-point presisi tunggal satu dimensi terkelola ke penunjuk memori yang tidak dikelola.
Copy(IntPtr, Single[], Int32, Int32)	Menyalin data dari penunjuk memori yang tidak dikelola ke array angka floating-point presisi tunggal terkelola.
Copy(IntPtr, IntPtr[], Int32, Int32)	Menyalin data dari penunjuk memori yang tidak dikelola ke array terkelola IntPtr .
Copy(IntPtr, Int64[], Int32, Int32)	Menyalin data dari penunjuk memori yang tidak dikelola ke array bilangan bulat yang ditandatangani 64-bit terkelola.
Copy(IntPtr, Int32[], Int32, Int32)	Menyalin data dari penunjuk memori yang tidak dikelola ke array bilangan bulat yang ditandatangani 32-bit terkelola.
Copy(IntPtr, Int16[], Int32, Int32)	Menyalin data dari penunjuk memori yang tidak dikelola ke array bilangan bulat yang ditandatangani 16-bit terkelola.
Copy(IntPtr, Double[], Int32, Int32)	Menyalin data dari penunjuk memori yang tidak dikelola ke array angka floating-point presisi ganda terkelola.
Copy(IntPtr[], Int32, IntPtr, Int32)	Menyalin data dari array terkelola IntPtr satu dimensi ke penunjuk memori yang tidak dikelola.
Copy(IntPtr, Byte[], Int32, Int32)	Menyalin data dari penunjuk memori yang tidak dikelola ke array bilangan bulat yang tidak ditandatangani 8-bit terkelola.
Copy(Int64[], Int32, IntPtr, Int32)	Menyalin data dari array bilangan bulat bertanda satu dimensi yang dikelola 64-bit ke penunjuk memori yang tidak dikelola.
Copy(Int32[], Int32, IntPtr, Int32)	Menyalin data dari array bilangan bulat bertanda satu dimensi yang dikelola 32-bit ke penunjuk memori yang tidak dikelola.
Copy(Int16[], Int32, IntPtr, Int32)	Menyalin data dari array bilangan bulat bertanda satu dimensi yang dikelola 16-bit ke penunjuk memori yang tidak dikelola.
Copy(Double[], Int32, IntPtr, Int32)	Menyalin data dari array angka floating-point presisi ganda yang dikelola satu dimensi ke penunjuk memori yang tidak dikelola.
Copy(Char[], Int32, IntPtr, Int32)	Menyalin data dari array karakter terkelola satu dimensi ke penunjuk memori yang tidak dikelola.
Copy(IntPtr, Char[], Int32, Int32)	Menyalin data dari penunjuk memori yang tidak dikelola ke array karakter terkelola.
Copy(Byte[], Int32, IntPtr, Int32)	Menyalin data dari array bilangan bulat 8-bit yang tidak ditandatangani satu dimensi ke penunjuk memori yang tidak dikelola.

Copy(Single[], Int32, IntPtr, Int32)

Sumber:

Marshal.cs

Menyalin data dari array angka floating-point presisi tunggal satu dimensi terkelola ke penunjuk memori yang tidak dikelola.

public:
 static void Copy(cli::array <float> ^ source, int startIndex, IntPtr destination, int length);

public static void Copy (float[] source, int startIndex, IntPtr destination, int length);

static member Copy : single[] * int * nativeint * int -> unit

Public Shared Sub Copy (source As Single(), startIndex As Integer, destination As IntPtr, length As Integer)

Parameter

source

Single[]

Array satu dimensi untuk disalin.

startIndex

Int32

Indeks berbasis nol dalam array sumber tempat penyalinan harus dimulai.

destination

IntPtr

nativeint

Penunjuk memori yang akan disalin.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentOutOfRangeException

startIndex dan length tidak valid.

ArgumentNullException

source, startIndex, destination, atau length adalah null.

Keterangan

Anda dapat menggunakan metode ini untuk menyalin subset array terkelola satu dimensi ke array gaya C yang tidak dikelola.

Copy(IntPtr, Single[], Int32, Int32)

Sumber:

Marshal.cs

Menyalin data dari penunjuk memori yang tidak dikelola ke array angka floating-point presisi tunggal terkelola.

public:
 static void Copy(IntPtr source, cli::array <float> ^ destination, int startIndex, int length);

public static void Copy (IntPtr source, float[] destination, int startIndex, int length);

static member Copy : nativeint * single[] * int * int -> unit

Public Shared Sub Copy (source As IntPtr, destination As Single(), startIndex As Integer, length As Integer)

Parameter

source

IntPtr

nativeint

Penunjuk memori untuk disalin.

destination

Single[]

Array yang akan disalin.

startIndex

Int32

Indeks berbasis nol dalam array tujuan tempat penyalinan harus dimulai.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentNullException

source, destination, startIndex, atau length adalah null.

Keterangan

Array gaya C yang tidak terkelola tidak berisi informasi terikat, yang mencegah startIndex parameter dan length divalidasi. Dengan demikian, data yang tidak dikelola yang sesuai dengan source parameter mengisi array terkelola terlepas dari kegunaannya. Anda harus menginisialisasi array terkelola dengan ukuran yang sesuai sebelum memanggil metode ini.

Lihat juga

• Copy(Int32[], Int32, IntPtr, Int32)

Copy(IntPtr, IntPtr[], Int32, Int32)

Sumber:

Marshal.cs

Menyalin data dari penunjuk memori yang tidak dikelola ke array terkelola IntPtr .

public:
 static void Copy(IntPtr source, cli::array <IntPtr> ^ destination, int startIndex, int length);

public static void Copy (IntPtr source, IntPtr[] destination, int startIndex, int length);

static member Copy : nativeint * nativeint[] * int * int -> unit

Public Shared Sub Copy (source As IntPtr, destination As IntPtr(), startIndex As Integer, length As Integer)

Parameter

source

IntPtr

nativeint

Penunjuk memori untuk disalin.

destination

IntPtr[]

nativeint[]

Array yang akan disalin.

startIndex

Int32

Indeks berbasis nol dalam array tujuan tempat penyalinan harus dimulai.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentNullException

source, destination, startIndex, atau length adalah null.

Keterangan

Array gaya C yang tidak terkelola tidak berisi informasi terikat, yang mencegah startIndex parameter dan length divalidasi. Oleh karena itu, data tidak terkelola yang sesuai dengan source parameter mengisi array terkelola terlepas dari kegunaannya. Anda harus menginisialisasi array terkelola dengan ukuran yang sesuai sebelum memanggil Marshal.Copy metode .

Copy(IntPtr, Int64[], Int32, Int32)

Sumber:

Marshal.cs

Menyalin data dari penunjuk memori yang tidak dikelola ke array bilangan bulat yang ditandatangani 64-bit terkelola.

public:
 static void Copy(IntPtr source, cli::array <long> ^ destination, int startIndex, int length);

public static void Copy (IntPtr source, long[] destination, int startIndex, int length);

static member Copy : nativeint * int64[] * int * int -> unit

Public Shared Sub Copy (source As IntPtr, destination As Long(), startIndex As Integer, length As Integer)

Parameter

source

IntPtr

nativeint

Penunjuk memori untuk disalin.

destination

Int64[]

Array yang akan disalin.

startIndex

Int32

Indeks berbasis nol dalam array tujuan tempat penyalinan harus dimulai.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentNullException

source, destination, startIndex, atau length adalah null.

Contoh

Contoh berikut menyalin array ke memori yang tidak dikelola lalu menyalin array yang tidak dikelola kembali ke memori terkelola.

using System;
using System.Runtime.InteropServices;

class Example
{

    static void Main()
    {
        // Create a managed array.
        Int64[] managedArray = { 1, 2, 3, 4 };

        // Initialize unmanaged memory to hold the array.
        int size = Marshal.SizeOf(managedArray[0]) * managedArray.Length;

        IntPtr pnt = Marshal.AllocHGlobal(size);

        try
        {
            // Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length);

            // Copy the unmanaged array back to another managed array.

            Int64[] managedArray2 = new Int64[managedArray.Length];

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length);

            Console.WriteLine("The array was copied to unmanaged memory and back.");
        }
        finally
        {
            // Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt);
        }
    }
}

Imports System.Runtime.InteropServices



Module Example


    Sub Main()
        ' Create a managed array.
        Dim managedArray As Int64() = {1, 2, 3, 4}

        ' Initialize unmanaged memory to hold the array.
        Dim size As Integer = Marshal.SizeOf(managedArray(0)) * managedArray.Length

        Dim pnt As IntPtr = Marshal.AllocHGlobal(size)

        Try
            ' Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length)

            ' Copy the unmanaged array back to another managed array.
            Dim managedArray2(managedArray.Length) As Int64

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length)

            Console.WriteLine("The array was copied to unmanaged memory and back.")

        Finally
            ' Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt)
        End Try

    End Sub
End Module

Keterangan

Array gaya C yang tidak terkelola tidak berisi informasi terikat, yang mencegah startIndex parameter dan length divalidasi. Dengan demikian, data yang tidak dikelola yang sesuai dengansource parameter mengisi array terkelola terlepas dari kegunaannya. Anda harus menginisialisasi array terkelola dengan ukuran yang sesuai sebelum memanggil metode ini.

Lihat juga

• Copy(Int32[], Int32, IntPtr, Int32)

Copy(IntPtr, Int32[], Int32, Int32)

Sumber:

Marshal.cs

Menyalin data dari penunjuk memori yang tidak dikelola ke array bilangan bulat yang ditandatangani 32-bit terkelola.

public:
 static void Copy(IntPtr source, cli::array <int> ^ destination, int startIndex, int length);

public static void Copy (IntPtr source, int[] destination, int startIndex, int length);

static member Copy : nativeint * int[] * int * int -> unit

Public Shared Sub Copy (source As IntPtr, destination As Integer(), startIndex As Integer, length As Integer)

Parameter

source

IntPtr

nativeint

Penunjuk memori untuk disalin.

destination

Int32[]

Array yang akan disalin.

startIndex

Int32

Indeks berbasis nol dalam array tujuan tempat penyalinan harus dimulai.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentNullException

source, destination, startIndex, atau length adalah null.

Contoh

Contoh berikut menyalin array ke memori yang tidak dikelola lalu menyalin array yang tidak dikelola kembali ke memori terkelola.

using System;
using System.Runtime.InteropServices;

class Example
{

    static void Main()
    {
        // Create a managed array.
        int[] managedArray = { 1, 2, 3, 4 };

        // Initialize unmanaged memory to hold the array.
        int size = Marshal.SizeOf(managedArray[0]) * managedArray.Length;

        IntPtr pnt = Marshal.AllocHGlobal(size);

        try
        {
            // Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length);

            // Copy the unmanaged array back to another managed array.

            int[] managedArray2 = new int[managedArray.Length];

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length);

            Console.WriteLine("The array was copied to unmanaged memory and back.");
        }
        finally
        {
            // Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt);
        }
    }
}

Imports System.Runtime.InteropServices



Module Example


    Sub Main()
        ' Create a managed array.
        Dim managedArray As Integer() = {1, 2, 3, 4}

        ' Initialize unmanaged memory to hold the array.
        Dim size As Integer = Marshal.SizeOf(managedArray(0)) * managedArray.Length

        Dim pnt As IntPtr = Marshal.AllocHGlobal(size)

        Try
            ' Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length)

            ' Copy the unmanaged array back to another managed array.
            Dim managedArray2(managedArray.Length) As Integer

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length)

            Console.WriteLine("The array was copied to unmanaged memory and back.")

        Finally
            ' Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt)
        End Try

    End Sub
End Module

Keterangan

Array gaya C yang tidak terkelola tidak berisi informasi terikat, yang mencegah startIndex parameter dan length divalidasi. Dengan demikian, data yang tidak dikelola yang sesuai dengan source parameter mengisi array terkelola terlepas dari kegunaannya. Anda harus menginisialisasi array terkelola dengan ukuran yang sesuai sebelum memanggil metode ini.

Lihat juga

• Copy(Int32[], Int32, IntPtr, Int32)

Copy(IntPtr, Int16[], Int32, Int32)

Sumber:

Marshal.cs

Menyalin data dari penunjuk memori yang tidak dikelola ke array bilangan bulat yang ditandatangani 16-bit terkelola.

public:
 static void Copy(IntPtr source, cli::array <short> ^ destination, int startIndex, int length);

public static void Copy (IntPtr source, short[] destination, int startIndex, int length);

static member Copy : nativeint * int16[] * int * int -> unit

Public Shared Sub Copy (source As IntPtr, destination As Short(), startIndex As Integer, length As Integer)

Parameter

source

IntPtr

nativeint

Penunjuk memori untuk disalin.

destination

Int16[]

Array yang akan disalin.

startIndex

Int32

Indeks berbasis nol dalam array tujuan tempat penyalinan harus dimulai.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentNullException

source, destination, startIndex, atau length adalah null.

Contoh

Contoh berikut menyalin array ke memori yang tidak dikelola lalu menyalin array yang tidak dikelola kembali ke memori terkelola.

using System;
using System.Runtime.InteropServices;

class Example
{

    static void Main()
    {
        // Create a managed array.
        short[] managedArray = { 1, 2, 3, 4 };

        // Initialize unmanaged memory to hold the array.
        int size = Marshal.SizeOf(managedArray[0]) * managedArray.Length;

        IntPtr pnt = Marshal.AllocHGlobal(size);

        try
        {
            // Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length);

            // Copy the unmanaged array back to another managed array.

            short[] managedArray2 = new short[managedArray.Length];

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length);

            Console.WriteLine("The array was copied to unmanaged memory and back.");
        }
        finally
        {
            // Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt);
        }
    }
}

Imports System.Runtime.InteropServices



Module Example


    Sub Main()
        ' Create a managed array.
        Dim managedArray As Short() = {1, 2, 3, 4}

        ' Initialize unmanaged memory to hold the array.
        Dim size As Integer = Marshal.SizeOf(managedArray(0)) * managedArray.Length

        Dim pnt As IntPtr = Marshal.AllocHGlobal(size)

        Try
            ' Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length)

            ' Copy the unmanaged array back to another managed array.
            Dim managedArray2(managedArray.Length) As Short

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length)

            Console.WriteLine("The array was copied to unmanaged memory and back.")

        Finally
            ' Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt)
        End Try

    End Sub
End Module

Keterangan

Array gaya C yang tidak terkelola tidak berisi informasi terikat, yang mencegah startIndex parameter dan length divalidasi. Dengan demikian, data yang tidak dikelola yang sesuai dengan source parameter mengisi array terkelola terlepas dari kegunaannya. Anda harus menginisialisasi array terkelola dengan ukuran yang sesuai sebelum memanggil metode ini.

Lihat juga

• Copy(Int32[], Int32, IntPtr, Int32)

Copy(IntPtr, Double[], Int32, Int32)

Sumber:

Marshal.cs

Menyalin data dari penunjuk memori yang tidak dikelola ke array angka floating-point presisi ganda terkelola.

public:
 static void Copy(IntPtr source, cli::array <double> ^ destination, int startIndex, int length);

public static void Copy (IntPtr source, double[] destination, int startIndex, int length);

static member Copy : nativeint * double[] * int * int -> unit

Public Shared Sub Copy (source As IntPtr, destination As Double(), startIndex As Integer, length As Integer)

Parameter

source

IntPtr

nativeint

Penunjuk memori untuk disalin.

destination

Double[]

Array yang akan disalin.

startIndex

Int32

Indeks berbasis nol dalam array tujuan tempat penyalinan harus dimulai.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentNullException

source, destination, startIndex, atau length adalah null.

Contoh

Contoh berikut menyalin array ke memori yang tidak dikelola lalu menyalin array yang tidak dikelola kembali ke memori terkelola.

using System;
using System.Runtime.InteropServices;

class Example
{

    static void Main()
    {
        // Create a managed array.
        double[] managedArray = { 0.1, 0.2, 0.3, 0.4 };

        // Initialize unmanaged memory to hold the array.
        int size = Marshal.SizeOf(managedArray[0]) * managedArray.Length;

        IntPtr pnt = Marshal.AllocHGlobal(size);

        try
        {
            // Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length);

            // Copy the unmanaged array back to another managed array.

            double[] managedArray2 = new double[managedArray.Length];

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length);

            Console.WriteLine("The array was copied to unmanaged memory and back.");
        }
        finally
        {
            // Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt);
        }
    }
}

Imports System.Runtime.InteropServices



Module Example


    Sub Main()
        ' Create a managed array.
        Dim managedArray As Double() = {0.1, 0.2, 0.3, 0.4}

        ' Initialize unmanaged memory to hold the array.
        Dim size As Integer = Marshal.SizeOf(managedArray(0)) * managedArray.Length

        Dim pnt As IntPtr = Marshal.AllocHGlobal(size)

        Try
            ' Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length)

            ' Copy the unmanaged array back to another managed array.
            Dim managedArray2(managedArray.Length) As Double

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length)

            Console.WriteLine("The array was copied to unmanaged memory and back.")

        Finally
            ' Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt)
        End Try

    End Sub
End Module

Keterangan

Array gaya C yang tidak terkelola tidak berisi informasi terikat, yang mencegah startIndex parameter dan length divalidasi. Dengan demikian, data yang tidak dikelola yang sesuai dengan source parameter mengisi array terkelola terlepas dari kegunaannya. Anda harus menginisialisasi array terkelola dengan ukuran yang sesuai sebelum memanggil metode ini.

Lihat juga

• Copy(Int32[], Int32, IntPtr, Int32)

Copy(IntPtr[], Int32, IntPtr, Int32)

Sumber:

Marshal.cs

Menyalin data dari array terkelola IntPtr satu dimensi ke penunjuk memori yang tidak dikelola.

public:
 static void Copy(cli::array <IntPtr> ^ source, int startIndex, IntPtr destination, int length);

public static void Copy (IntPtr[] source, int startIndex, IntPtr destination, int length);

static member Copy : nativeint[] * int * nativeint * int -> unit

Public Shared Sub Copy (source As IntPtr(), startIndex As Integer, destination As IntPtr, length As Integer)

Parameter

source

IntPtr[]

nativeint[]

Array satu dimensi untuk disalin.

startIndex

Int32

Indeks berbasis nol dalam array sumber tempat penyalinan harus dimulai.

destination

IntPtr

nativeint

Penunjuk memori yang akan disalin.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentNullException

source, destination, startIndex, atau length adalah null.

Keterangan

Anda dapat menggunakan metode ini untuk menyalin subset array terkelola IntPtr satu dimensi ke array gaya C yang tidak dikelola.

Copy(IntPtr, Byte[], Int32, Int32)

Sumber:

Marshal.cs

Menyalin data dari penunjuk memori yang tidak dikelola ke array bilangan bulat yang tidak ditandatangani 8-bit terkelola.

public:
 static void Copy(IntPtr source, cli::array <System::Byte> ^ destination, int startIndex, int length);

public static void Copy (IntPtr source, byte[] destination, int startIndex, int length);

static member Copy : nativeint * byte[] * int * int -> unit

Public Shared Sub Copy (source As IntPtr, destination As Byte(), startIndex As Integer, length As Integer)

Parameter

source

IntPtr

nativeint

Penunjuk memori untuk disalin.

destination

Byte[]

Array yang akan disalin.

startIndex

Int32

Indeks berbasis nol dalam array tujuan tempat penyalinan harus dimulai.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentNullException

source, destination, startIndex, atau length adalah null.

Contoh

Contoh berikut menyalin array ke memori yang tidak dikelola lalu menyalin array yang tidak dikelola kembali ke memori terkelola.

using System;
using System.Runtime.InteropServices;

class Example
{

    static void Main()
    {
        // Create a managed array.
        byte[] managedArray = { 1, 2, 3, 4 };

        // Initialize unmanaged memory to hold the array.
        int size = Marshal.SizeOf(managedArray[0]) * managedArray.Length;

        IntPtr pnt = Marshal.AllocHGlobal(size);

        try
        {
            // Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length);

            // Copy the unmanaged array back to another managed array.

            byte[] managedArray2 = new byte[managedArray.Length];

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length);

            Console.WriteLine("The array was copied to unmanaged memory and back.");
        }
        finally
        {
            // Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt);
        }
    }
}

Imports System.Runtime.InteropServices



Module Example


    Sub Main()
        ' Create a managed array.
        Dim managedArray As Byte() = {1, 2, 3, 4}

        ' Initialize unmanaged memory to hold the array.
        Dim size As Integer = Marshal.SizeOf(managedArray(0)) * managedArray.Length

        Dim pnt As IntPtr = Marshal.AllocHGlobal(size)

        Try
            ' Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length)

            ' Copy the unmanaged array back to another managed array.
            Dim managedArray2(managedArray.Length) As Byte

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length)

            Console.WriteLine("The array was copied to unmanaged memory and back.")

        Finally
            ' Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt)
        End Try

    End Sub
End Module

Keterangan

Array gaya C yang tidak terkelola tidak berisi informasi terikat, yang mencegah startIndex parameter dan length divalidasi. Dengan demikian, data yang tidak dikelola yang sesuai dengan source parameter mengisi array terkelola terlepas dari kegunaannya. Anda harus menginisialisasi array terkelola dengan ukuran yang sesuai sebelum memanggil metode ini.

Lihat juga

• Copy(Int32[], Int32, IntPtr, Int32)

Copy(Int64[], Int32, IntPtr, Int32)

Sumber:

Marshal.cs

Menyalin data dari array bilangan bulat bertanda satu dimensi yang dikelola 64-bit ke penunjuk memori yang tidak dikelola.

public:
 static void Copy(cli::array <long> ^ source, int startIndex, IntPtr destination, int length);

public static void Copy (long[] source, int startIndex, IntPtr destination, int length);

static member Copy : int64[] * int * nativeint * int -> unit

Public Shared Sub Copy (source As Long(), startIndex As Integer, destination As IntPtr, length As Integer)

Parameter

source

Int64[]

Array satu dimensi untuk disalin.

startIndex

Int32

Indeks berbasis nol dalam array sumber tempat penyalinan harus dimulai.

destination

IntPtr

nativeint

Penunjuk memori yang akan disalin.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentOutOfRangeException

startIndex dan length tidak valid.

ArgumentNullException

source, startIndex, destination, atau length adalah null.

Contoh

Contoh berikut menyalin array ke memori yang tidak dikelola lalu menyalin array yang tidak dikelola kembali ke memori terkelola.

using System;
using System.Runtime.InteropServices;

class Example
{

    static void Main()
    {
        // Create a managed array.
        Int64[] managedArray = { 1, 2, 3, 4 };

        // Initialize unmanaged memory to hold the array.
        int size = Marshal.SizeOf(managedArray[0]) * managedArray.Length;

        IntPtr pnt = Marshal.AllocHGlobal(size);

        try
        {
            // Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length);

            // Copy the unmanaged array back to another managed array.

            Int64[] managedArray2 = new Int64[managedArray.Length];

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length);

            Console.WriteLine("The array was copied to unmanaged memory and back.");
        }
        finally
        {
            // Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt);
        }
    }
}

Imports System.Runtime.InteropServices



Module Example


    Sub Main()
        ' Create a managed array.
        Dim managedArray As Int64() = {1, 2, 3, 4}

        ' Initialize unmanaged memory to hold the array.
        Dim size As Integer = Marshal.SizeOf(managedArray(0)) * managedArray.Length

        Dim pnt As IntPtr = Marshal.AllocHGlobal(size)

        Try
            ' Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length)

            ' Copy the unmanaged array back to another managed array.
            Dim managedArray2(managedArray.Length) As Int64

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length)

            Console.WriteLine("The array was copied to unmanaged memory and back.")

        Finally
            ' Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt)
        End Try

    End Sub
End Module

Keterangan

Anda dapat menggunakan metode ini untuk menyalin subset array terkelola satu dimensi ke array gaya C yang tidak dikelola.

Copy(Int32[], Int32, IntPtr, Int32)

Sumber:

Marshal.cs

Menyalin data dari array bilangan bulat bertanda satu dimensi yang dikelola 32-bit ke penunjuk memori yang tidak dikelola.

public:
 static void Copy(cli::array <int> ^ source, int startIndex, IntPtr destination, int length);

public static void Copy (int[] source, int startIndex, IntPtr destination, int length);

static member Copy : int[] * int * nativeint * int -> unit

Public Shared Sub Copy (source As Integer(), startIndex As Integer, destination As IntPtr, length As Integer)

Parameter

source

Int32[]

Array satu dimensi untuk disalin.

startIndex

Int32

Indeks berbasis nol dalam array sumber tempat penyalinan harus dimulai.

destination

IntPtr

nativeint

Penunjuk memori yang akan disalin.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentOutOfRangeException

startIndex dan length tidak valid.

ArgumentNullException

startIndex atau length adalah null.

Contoh

Contoh berikut menyalin array ke memori yang tidak dikelola lalu menyalin array yang tidak dikelola kembali ke memori terkelola.

using System;
using System.Runtime.InteropServices;

class Example
{

    static void Main()
    {
        // Create a managed array.
        int[] managedArray = { 1, 2, 3, 4 };

        // Initialize unmanaged memory to hold the array.
        int size = Marshal.SizeOf(managedArray[0]) * managedArray.Length;

        IntPtr pnt = Marshal.AllocHGlobal(size);

        try
        {
            // Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length);

            // Copy the unmanaged array back to another managed array.

            int[] managedArray2 = new int[managedArray.Length];

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length);

            Console.WriteLine("The array was copied to unmanaged memory and back.");
        }
        finally
        {
            // Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt);
        }
    }
}

Imports System.Runtime.InteropServices



Module Example


    Sub Main()
        ' Create a managed array.
        Dim managedArray As Integer() = {1, 2, 3, 4}

        ' Initialize unmanaged memory to hold the array.
        Dim size As Integer = Marshal.SizeOf(managedArray(0)) * managedArray.Length

        Dim pnt As IntPtr = Marshal.AllocHGlobal(size)

        Try
            ' Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length)

            ' Copy the unmanaged array back to another managed array.
            Dim managedArray2(managedArray.Length) As Integer

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length)

            Console.WriteLine("The array was copied to unmanaged memory and back.")

        Finally
            ' Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt)
        End Try

    End Sub
End Module

Keterangan

Anda dapat menggunakan metode ini untuk menyalin subset array terkelola satu dimensi ke array gaya C yang tidak dikelola.

Copy(Int16[], Int32, IntPtr, Int32)

Sumber:

Marshal.cs

Menyalin data dari array bilangan bulat bertanda satu dimensi yang dikelola 16-bit ke penunjuk memori yang tidak dikelola.

public:
 static void Copy(cli::array <short> ^ source, int startIndex, IntPtr destination, int length);

public static void Copy (short[] source, int startIndex, IntPtr destination, int length);

static member Copy : int16[] * int * nativeint * int -> unit

Public Shared Sub Copy (source As Short(), startIndex As Integer, destination As IntPtr, length As Integer)

Parameter

source

Int16[]

Array satu dimensi untuk disalin.

startIndex

Int32

Indeks berbasis nol dalam array sumber tempat penyalinan harus dimulai.

destination

IntPtr

nativeint

Penunjuk memori yang akan disalin.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentOutOfRangeException

startIndex dan length tidak valid.

ArgumentNullException

source, startIndex, destination, atau length adalah null.

Contoh

Contoh berikut menyalin array ke memori yang tidak dikelola lalu menyalin array yang tidak dikelola kembali ke memori terkelola.

using System;
using System.Runtime.InteropServices;

class Example
{

    static void Main()
    {
        // Create a managed array.
        short[] managedArray = { 1, 2, 3, 4 };

        // Initialize unmanaged memory to hold the array.
        int size = Marshal.SizeOf(managedArray[0]) * managedArray.Length;

        IntPtr pnt = Marshal.AllocHGlobal(size);

        try
        {
            // Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length);

            // Copy the unmanaged array back to another managed array.

            short[] managedArray2 = new short[managedArray.Length];

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length);

            Console.WriteLine("The array was copied to unmanaged memory and back.");
        }
        finally
        {
            // Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt);
        }
    }
}

Imports System.Runtime.InteropServices



Module Example


    Sub Main()
        ' Create a managed array.
        Dim managedArray As Short() = {1, 2, 3, 4}

        ' Initialize unmanaged memory to hold the array.
        Dim size As Integer = Marshal.SizeOf(managedArray(0)) * managedArray.Length

        Dim pnt As IntPtr = Marshal.AllocHGlobal(size)

        Try
            ' Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length)

            ' Copy the unmanaged array back to another managed array.
            Dim managedArray2(managedArray.Length) As Short

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length)

            Console.WriteLine("The array was copied to unmanaged memory and back.")

        Finally
            ' Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt)
        End Try

    End Sub
End Module

Keterangan

Anda dapat menggunakan metode ini untuk menyalin subset array terkelola satu dimensi ke array gaya C yang tidak dikelola.

Copy(Double[], Int32, IntPtr, Int32)

Sumber:

Marshal.cs

Menyalin data dari array angka floating-point presisi ganda yang dikelola satu dimensi ke penunjuk memori yang tidak dikelola.

public:
 static void Copy(cli::array <double> ^ source, int startIndex, IntPtr destination, int length);

public static void Copy (double[] source, int startIndex, IntPtr destination, int length);

static member Copy : double[] * int * nativeint * int -> unit

Public Shared Sub Copy (source As Double(), startIndex As Integer, destination As IntPtr, length As Integer)

Parameter

source

Double[]

Array satu dimensi untuk disalin.

startIndex

Int32

Indeks berbasis nol dalam array sumber tempat penyalinan harus dimulai.

destination

IntPtr

nativeint

Penunjuk memori yang akan disalin.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentOutOfRangeException

startIndex dan length tidak valid.

ArgumentNullException

source, startIndex, destination, atau length adalah null.

Contoh

Contoh berikut menyalin array ke memori yang tidak dikelola lalu menyalin array yang tidak dikelola kembali ke memori terkelola.

using System;
using System.Runtime.InteropServices;

class Example
{

    static void Main()
    {
        // Create a managed array.
        double[] managedArray = { 0.1, 0.2, 0.3, 0.4 };

        // Initialize unmanaged memory to hold the array.
        int size = Marshal.SizeOf(managedArray[0]) * managedArray.Length;

        IntPtr pnt = Marshal.AllocHGlobal(size);

        try
        {
            // Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length);

            // Copy the unmanaged array back to another managed array.

            double[] managedArray2 = new double[managedArray.Length];

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length);

            Console.WriteLine("The array was copied to unmanaged memory and back.");
        }
        finally
        {
            // Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt);
        }
    }
}

Imports System.Runtime.InteropServices



Module Example


    Sub Main()
        ' Create a managed array.
        Dim managedArray As Double() = {0.1, 0.2, 0.3, 0.4}

        ' Initialize unmanaged memory to hold the array.
        Dim size As Integer = Marshal.SizeOf(managedArray(0)) * managedArray.Length

        Dim pnt As IntPtr = Marshal.AllocHGlobal(size)

        Try
            ' Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length)

            ' Copy the unmanaged array back to another managed array.
            Dim managedArray2(managedArray.Length) As Double

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length)

            Console.WriteLine("The array was copied to unmanaged memory and back.")

        Finally
            ' Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt)
        End Try

    End Sub
End Module

Keterangan

Anda dapat menggunakan metode ini untuk menyalin subset array terkelola satu dimensi ke array gaya C yang tidak dikelola.

Copy(Char[], Int32, IntPtr, Int32)

Sumber:

Marshal.cs

Menyalin data dari array karakter terkelola satu dimensi ke penunjuk memori yang tidak dikelola.

public:
 static void Copy(cli::array <char> ^ source, int startIndex, IntPtr destination, int length);

public static void Copy (char[] source, int startIndex, IntPtr destination, int length);

static member Copy : char[] * int * nativeint * int -> unit

Public Shared Sub Copy (source As Char(), startIndex As Integer, destination As IntPtr, length As Integer)

Parameter

source

Char[]

Array satu dimensi untuk disalin.

startIndex

Int32

Indeks berbasis nol dalam array sumber tempat penyalinan harus dimulai.

destination

IntPtr

nativeint

Penunjuk memori yang akan disalin.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentOutOfRangeException

startIndex dan length tidak valid.

ArgumentNullException

startIndex, destination, atau length adalah null.

Contoh

Contoh berikut menyalin array ke memori yang tidak dikelola lalu menyalin array yang tidak dikelola kembali ke memori terkelola.

// Remember that the actual size of System.Char in unmanaged memory is 2.
using System;
using System.Runtime.InteropServices;

class Example
{

    static void Main()
    {
        // Create a managed array.
        char[] managedArray = new char[1000];
        managedArray[0] = 'a';
        managedArray[1] = 'b';
        managedArray[2] = 'c';
        managedArray[3] = 'd';
        managedArray[999] = 'Z';

        // Initialize unmanaged memory to hold the array.
        // int size = Marshal.SizeOf(managedArray[0]) * managedArray.Length;  // Incorrect
        int size = Marshal.SystemDefaultCharSize * managedArray.Length;       // Correct

        IntPtr pnt = Marshal.AllocHGlobal(size);

        try
        {
            // Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length);

            // Copy the unmanaged array back to another managed array.

            char[] managedArray2 = new char[managedArray.Length];

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length);
            Console.WriteLine("Here is the roundtripped array: {0} {1} {2} {3} {4}",
                               managedArray2[0], managedArray2[1], managedArray2[2], managedArray2[3],
                               managedArray2[999]);

            Console.WriteLine("The array was copied to unmanaged memory and back.");
        }
        finally
        {
            // Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt);
        }
    }
}

' Remember that the actual size of System.Char in unmanaged memory is 2.

Imports System.Runtime.InteropServices



Module Module1

    Sub Main()
        ' Create a managed array.
        Dim managedArray As Char() = New Char(999) {}
        managedArray(0) = "a"c
        managedArray(1) = "b"c
        managedArray(2) = "c"c
        managedArray(3) = "d"c
        managedArray(999) = "Z"c

        ' Initialize unmanaged memory to hold the array.
        ' Dim size As Integer = Marshal.SizeOf(managedArray[0]) * managedArray.Length;  ' Incorrect
        Dim size As Integer = Marshal.SystemDefaultCharSize * managedArray.Length       ' Correct

        Dim pnt As IntPtr = Marshal.AllocHGlobal(size)

        Try
            ' Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length)

            ' Copy the unmanaged array back to another managed array.

            Dim managedArray2 As Char() = New Char(managedArray.Length - 1) {}

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length)
            Console.WriteLine("Here is the roundtripped array: {0} {1} {2} {3} {4}", managedArray2(0), managedArray2(1), managedArray2(2), managedArray2(3), managedArray2(999))


            Console.WriteLine("The array was copied to unmanaged memory and back.")
        Finally
            ' Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt)

        End Try
    End Sub
End Module

Keterangan

Anda dapat menggunakan metode ini untuk menyalin subset array terkelola satu dimensi ke array gaya C yang tidak dikelola.

Copy(IntPtr, Char[], Int32, Int32)

Sumber:

Marshal.cs

Menyalin data dari penunjuk memori yang tidak dikelola ke array karakter terkelola.

public:
 static void Copy(IntPtr source, cli::array <char> ^ destination, int startIndex, int length);

public static void Copy (IntPtr source, char[] destination, int startIndex, int length);

static member Copy : nativeint * char[] * int * int -> unit

Public Shared Sub Copy (source As IntPtr, destination As Char(), startIndex As Integer, length As Integer)

Parameter

source

IntPtr

nativeint

Penunjuk memori untuk disalin.

destination

Char[]

Array yang akan disalin.

startIndex

Int32

Indeks berbasis nol dalam array tujuan tempat penyalinan harus dimulai.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentNullException

source, destination, startIndex, atau length adalah null.

Contoh

Contoh berikut menyalin array ke memori yang tidak dikelola lalu menyalin array yang tidak dikelola kembali ke memori terkelola.

// Remember that the actual size of System.Char in unmanaged memory is 2.
using System;
using System.Runtime.InteropServices;

class Example
{

    static void Main()
    {
        // Create a managed array.
        char[] managedArray = new char[1000];
        managedArray[0] = 'a';
        managedArray[1] = 'b';
        managedArray[2] = 'c';
        managedArray[3] = 'd';
        managedArray[999] = 'Z';

        // Initialize unmanaged memory to hold the array.
        // int size = Marshal.SizeOf(managedArray[0]) * managedArray.Length;  // Incorrect
        int size = Marshal.SystemDefaultCharSize * managedArray.Length;       // Correct

        IntPtr pnt = Marshal.AllocHGlobal(size);

        try
        {
            // Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length);

            // Copy the unmanaged array back to another managed array.

            char[] managedArray2 = new char[managedArray.Length];

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length);
            Console.WriteLine("Here is the roundtripped array: {0} {1} {2} {3} {4}",
                               managedArray2[0], managedArray2[1], managedArray2[2], managedArray2[3],
                               managedArray2[999]);

            Console.WriteLine("The array was copied to unmanaged memory and back.");
        }
        finally
        {
            // Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt);
        }
    }
}

' Remember that the actual size of System.Char in unmanaged memory is 2.

Imports System.Runtime.InteropServices



Module Module1

    Sub Main()
        ' Create a managed array.
        Dim managedArray As Char() = New Char(999) {}
        managedArray(0) = "a"c
        managedArray(1) = "b"c
        managedArray(2) = "c"c
        managedArray(3) = "d"c
        managedArray(999) = "Z"c

        ' Initialize unmanaged memory to hold the array.
        ' Dim size As Integer = Marshal.SizeOf(managedArray[0]) * managedArray.Length;  ' Incorrect
        Dim size As Integer = Marshal.SystemDefaultCharSize * managedArray.Length       ' Correct

        Dim pnt As IntPtr = Marshal.AllocHGlobal(size)

        Try
            ' Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length)

            ' Copy the unmanaged array back to another managed array.

            Dim managedArray2 As Char() = New Char(managedArray.Length - 1) {}

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length)
            Console.WriteLine("Here is the roundtripped array: {0} {1} {2} {3} {4}", managedArray2(0), managedArray2(1), managedArray2(2), managedArray2(3), managedArray2(999))


            Console.WriteLine("The array was copied to unmanaged memory and back.")
        Finally
            ' Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt)

        End Try
    End Sub
End Module

Keterangan

Array gaya C yang tidak terkelola tidak berisi informasi terikat, yang mencegah startIndex parameter dan length divalidasi. Dengan demikian, data yang tidak dikelola yang sesuai dengan source parameter mengisi array terkelola terlepas dari kegunaannya. Anda harus menginisialisasi array terkelola dengan ukuran yang sesuai sebelum memanggil metode ini.

Lihat juga

• Copy(Int32[], Int32, IntPtr, Int32)

Copy(Byte[], Int32, IntPtr, Int32)

Sumber:

Marshal.cs

Menyalin data dari array bilangan bulat 8-bit yang tidak ditandatangani satu dimensi ke penunjuk memori yang tidak dikelola.

public:
 static void Copy(cli::array <System::Byte> ^ source, int startIndex, IntPtr destination, int length);

public static void Copy (byte[] source, int startIndex, IntPtr destination, int length);

static member Copy : byte[] * int * nativeint * int -> unit

Public Shared Sub Copy (source As Byte(), startIndex As Integer, destination As IntPtr, length As Integer)

Parameter

source

Byte[]

Array satu dimensi untuk disalin.

startIndex

Int32

Indeks berbasis nol dalam array sumber tempat penyalinan harus dimulai.

destination

IntPtr

nativeint

Penunjuk memori yang akan disalin.

length

Int32

Jumlah elemen array yang akan disalin.

Pengecualian

ArgumentOutOfRangeException

startIndex dan length tidak valid.

ArgumentNullException

source, startIndex, destination, atau length adalah null.

Contoh

Contoh berikut menyalin array ke memori yang tidak dikelola dengan menggunakan Copy(Byte[], Int32, IntPtr, Int32) kelebihan beban, lalu menyalin array yang tidak dikelola kembali ke memori terkelola dengan menggunakan Copy(IntPtr, Byte[], Int32, Int32) kelebihan beban.

using System;
using System.Runtime.InteropServices;

class Example
{

    static void Main()
    {
        // Create a managed array.
        byte[] managedArray = { 1, 2, 3, 4 };

        // Initialize unmanaged memory to hold the array.
        int size = Marshal.SizeOf(managedArray[0]) * managedArray.Length;

        IntPtr pnt = Marshal.AllocHGlobal(size);

        try
        {
            // Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length);

            // Copy the unmanaged array back to another managed array.

            byte[] managedArray2 = new byte[managedArray.Length];

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length);

            Console.WriteLine("The array was copied to unmanaged memory and back.");
        }
        finally
        {
            // Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt);
        }
    }
}

Imports System.Runtime.InteropServices



Module Example


    Sub Main()
        ' Create a managed array.
        Dim managedArray As Byte() = {1, 2, 3, 4}

        ' Initialize unmanaged memory to hold the array.
        Dim size As Integer = Marshal.SizeOf(managedArray(0)) * managedArray.Length

        Dim pnt As IntPtr = Marshal.AllocHGlobal(size)

        Try
            ' Copy the array to unmanaged memory.
            Marshal.Copy(managedArray, 0, pnt, managedArray.Length)

            ' Copy the unmanaged array back to another managed array.
            Dim managedArray2(managedArray.Length) As Byte

            Marshal.Copy(pnt, managedArray2, 0, managedArray.Length)

            Console.WriteLine("The array was copied to unmanaged memory and back.")

        Finally
            ' Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt)
        End Try

    End Sub
End Module

Keterangan

Anda dapat menggunakan metode ini untuk menyalin subset array terkelola satu dimensi ke array gaya C yang tidak dikelola.