Marshal.Copy Metoda

Definice

Obor názvů:

System.Runtime.InteropServices

Sestavení:

System.Runtime.InteropServices.dll

Zkopíruje data ze spravovaného pole do nespravovaného ukazatele paměti nebo z nespravovaného ukazatele paměti do spravovaného pole.

Přetížení

Copy(Single[], Int32, IntPtr, Int32)	Zkopíruje data z jednorozměrného spravovaného číselného pole s plovoucí desetinou čárkou s jednoduchou přesností do nespravovaného ukazatele paměti.
Copy(IntPtr, Single[], Int32, Int32)	Zkopíruje data z nespravovaného paměťového ukazatele do spravovaného číselného pole s plovoucí desetinou čárkou s jednoduchou přesností.
Copy(IntPtr, IntPtr[], Int32, Int32)	Zkopíruje data z nespravovaného ukazatele paměti do spravovaného IntPtr pole.
Copy(IntPtr, Int64[], Int32, Int32)	Zkopíruje data z nespravovaného ukazatele paměti do spravovaného 64bitového celočíselného pole se znaménkem.
Copy(IntPtr, Int32[], Int32, Int32)	Zkopíruje data z nespravovaného paměťového ukazatele do spravovaného 32bitového celočíselného pole se znaménkem.
Copy(IntPtr, Int16[], Int32, Int32)	Zkopíruje data z nespravovaného paměťového ukazatele do spravovaného 16bitového celočíselného pole se znaménkem.
Copy(IntPtr, Double[], Int32, Int32)	Zkopíruje data z nespravovaného paměťového ukazatele do spravovaného číselného pole s plovoucí desetinou čárkou s dvojitou přesností.
Copy(IntPtr[], Int32, IntPtr, Int32)	Zkopíruje data z jednorozměrného spravovaného IntPtr pole do nespravovaného ukazatele paměti.
Copy(IntPtr, Byte[], Int32, Int32)	Zkopíruje data z nespravovaného paměťového ukazatele do spravovaného 8bitového celočíselného pole bez znaménka.
Copy(Int64[], Int32, IntPtr, Int32)	Zkopíruje data z jednorozměrného spravovaného 64bitového celočíselného pole do nespravovaného ukazatele paměti.
Copy(Int32[], Int32, IntPtr, Int32)	Zkopíruje data z jednorozměrného spravovaného 32bitového celočíselného pole se znaménkem do nespravovaného ukazatele paměti.
Copy(Int16[], Int32, IntPtr, Int32)	Zkopíruje data z jednorozměrného spravovaného 16bitového celočíselného pole se znaménkem do nespravovaného ukazatele paměti.
Copy(Double[], Int32, IntPtr, Int32)	Zkopíruje data z jednorozměrného, spravovaného číselného pole s plovoucí desetinou čárkou s dvojitou přesností do nespravovaného ukazatele paměti.
Copy(Char[], Int32, IntPtr, Int32)	Zkopíruje data z jednorozměrného spravovaného pole znaků do nespravovaného ukazatele paměti.
Copy(IntPtr, Char[], Int32, Int32)	Zkopíruje data z nespravovaného paměťového ukazatele do pole spravovaných znaků.
Copy(Byte[], Int32, IntPtr, Int32)	Zkopíruje data z jednorozměrného, spravovaného 8bitového celočíselného pole bez znaménka do nespravovaného ukazatele paměti.

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

Zdroj:

Marshal.cs

Zkopíruje data z jednorozměrného spravovaného číselného pole s plovoucí desetinou čárkou s jednoduchou přesností do nespravovaného ukazatele paměti.

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)

Parametry

source

Single[]

Jednorozměrné pole, ze které se má kopírovat.

startIndex

Int32

Index založený na nule ve zdrojovém poli, kde by mělo kopírování začít.

destination

IntPtr

nativeint

Ukazatel paměti, do které chcete kopírovat.

length

Int32

Počet prvků pole, které mají být zkopírovány.

Výjimky

ArgumentOutOfRangeException

startIndex a length nejsou platné.

ArgumentNullException

source, startIndex, destinationnebo length je null.

Poznámky

Tuto metodu můžete použít ke zkopírování podmnožinu jednorozměrného spravovaného pole do nespravovaného pole ve stylu jazyka C.

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

Zdroj:

Marshal.cs

Zkopíruje data z nespravovaného paměťového ukazatele do spravovaného číselného pole s plovoucí desetinou čárkou s jednoduchou přesností.

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)

Parametry

source

IntPtr

nativeint

Ukazatel paměti, ze které chcete kopírovat.

destination

Single[]

Pole, do které se má kopírovat.

startIndex

Int32

Index založený na nule v cílovém poli, kde by mělo kopírování začít.

length

Int32

Počet prvků pole, které mají být zkopírovány.

Výjimky

ArgumentNullException

source, destination, startIndexnebo length je null.

Poznámky

Nespravovaná pole ve stylu jazyka C neobsahují informace o mezích, což brání startIndex ověření parametrů a length . Proto nespravovaná data odpovídající parametru source naplní spravované pole bez ohledu na jeho užitečnost. Před voláním této metody je nutné inicializovat spravované pole s odpovídající velikostí.

Viz také

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

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

Zdroj:

Marshal.cs

Zkopíruje data z nespravovaného ukazatele paměti do spravovaného IntPtr pole.

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)

Parametry

source

IntPtr

nativeint

Ukazatel paměti, ze které chcete kopírovat.

destination

IntPtr[]

nativeint[]

Pole, do které se má kopírovat.

startIndex

Int32

Index založený na nule v cílovém poli, kde by mělo kopírování začít.

length

Int32

Počet prvků pole, které mají být zkopírovány.

Výjimky

ArgumentNullException

source, destination, startIndexnebo length je null.

Poznámky

Nespravovaná pole ve stylu jazyka C neobsahují informace o mezích, což brání startIndex ověření parametrů a length . Proto nespravovaná data, která odpovídají parametru source , naplní spravované pole bez ohledu na jeho užitečnost. Před voláním Marshal.Copy metody je nutné inicializovat spravované pole s odpovídající velikostí.

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

Zdroj:

Marshal.cs

Zkopíruje data z nespravovaného ukazatele paměti do spravovaného 64bitového celočíselného pole se znaménkem.

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)

Parametry

source

IntPtr

nativeint

Ukazatel paměti, ze které chcete kopírovat.

destination

Int64[]

Pole, do které se má kopírovat.

startIndex

Int32

Index založený na nule v cílovém poli, kde by mělo kopírování začít.

length

Int32

Počet prvků pole, které mají být zkopírovány.

Výjimky

ArgumentNullException

source, destination, startIndexnebo length je null.

Příklady

Následující příklad zkopíruje pole do nespravované paměti a pak zkopíruje nespravované pole zpět do spravované paměti.

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

Poznámky

Nespravovaná pole ve stylu jazyka C neobsahují informace o mezích, což brání startIndex ověření parametrů a length . Proto nespravovaná data odpovídající parametrusource naplní spravované pole bez ohledu na jeho užitečnost. Před voláním této metody je nutné inicializovat spravované pole s odpovídající velikostí.

Viz také

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

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

Zdroj:

Marshal.cs

Zkopíruje data z nespravovaného paměťového ukazatele do spravovaného 32bitového celočíselného pole se znaménkem.

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)

Parametry

source

IntPtr

nativeint

Ukazatel paměti, ze které chcete kopírovat.

destination

Int32[]

Pole, do které se má kopírovat.

startIndex

Int32

Index založený na nule v cílovém poli, kde by mělo kopírování začít.

length

Int32

Počet prvků pole, které mají být zkopírovány.

Výjimky

ArgumentNullException

source, destination, startIndexnebo length je null.

Příklady

Následující příklad zkopíruje pole do nespravované paměti a pak zkopíruje nespravované pole zpět do spravované paměti.

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

Poznámky

Nespravovaná pole ve stylu jazyka C neobsahují informace o mezích, což brání startIndex ověření parametrů a length . Proto nespravovaná data odpovídající parametru source naplní spravované pole bez ohledu na jeho užitečnost. Před voláním této metody je nutné inicializovat spravované pole s odpovídající velikostí.

Viz také

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

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

Zdroj:

Marshal.cs

Zkopíruje data z nespravovaného paměťového ukazatele do spravovaného 16bitového celočíselného pole se znaménkem.

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)

Parametry

source

IntPtr

nativeint

Ukazatel paměti, ze které chcete kopírovat.

destination

Int16[]

Pole, do které se má kopírovat.

startIndex

Int32

Index založený na nule v cílovém poli, kde by mělo kopírování začít.

length

Int32

Počet prvků pole, které mají být zkopírovány.

Výjimky

ArgumentNullException

source, destination, startIndexnebo length je null.

Příklady

Následující příklad zkopíruje pole do nespravované paměti a pak zkopíruje nespravované pole zpět do spravované paměti.

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

Poznámky

Nespravovaná pole ve stylu jazyka C neobsahují informace o mezích, což brání startIndex ověření parametrů a length . Proto nespravovaná data odpovídající parametru source naplní spravované pole bez ohledu na jeho užitečnost. Před voláním této metody je nutné inicializovat spravované pole s odpovídající velikostí.

Viz také

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

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

Zdroj:

Marshal.cs

Zkopíruje data z nespravovaného ukazatele paměti do spravovaného číselného pole s plovoucí desetinou čárkou s dvojitou přesností.

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)

Parametry

source

IntPtr

nativeint

Ukazatel paměti, ze které chcete kopírovat.

destination

Double[]

Pole, do které se má kopírovat.

startIndex

Int32

Index založený na nule v cílovém poli, kde by mělo kopírování začít.

length

Int32

Počet prvků pole, které mají být zkopírovány.

Výjimky

ArgumentNullException

source, destination, startIndexnebo length je null.

Příklady

Následující příklad zkopíruje pole do nespravované paměti a pak zkopíruje nespravované pole zpět do spravované paměti.

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

Poznámky

Nespravovaná pole ve stylu jazyka C neobsahují informace o mezích, což brání startIndex ověření parametrů a length . Proto nespravovaná data odpovídající parametru source naplní spravované pole bez ohledu na jeho užitečnost. Před voláním této metody je nutné inicializovat spravované pole s odpovídající velikostí.

Viz také

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

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

Zdroj:

Marshal.cs

Zkopíruje data z jednorozměrného spravovaného IntPtr pole do nespravovaného ukazatele paměti.

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)

Parametry

source

IntPtr[]

nativeint[]

Jednorozměrné pole, ze které chcete kopírovat.

startIndex

Int32

Index založený na nule ve zdrojovém poli, kde by mělo být kopírování zahájeno.

destination

IntPtr

nativeint

Ukazatel paměti, do který chcete zkopírovat.

length

Int32

Počet prvků pole, které se mají zkopírovat.

Výjimky

ArgumentNullException

source, destination, startIndexnebo length je null.

Poznámky

Pomocí této metody můžete zkopírovat podmnožinu jednorozměrného spravovaného IntPtr pole do nespravovaného pole ve stylu C.

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

Zdroj:

Marshal.cs

Zkopíruje data z nespravovaného ukazatele paměti do spravovaného 8bitového celočíselného pole bez znaménka.

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)

Parametry

source

IntPtr

nativeint

Ukazatel paměti, ze které chcete kopírovat.

destination

Byte[]

Pole, do které chcete kopírovat.

startIndex

Int32

Index založený na nule v cílovém poli, kde by mělo být kopírování zahájeno.

length

Int32

Počet prvků pole, které se mají zkopírovat.

Výjimky

ArgumentNullException

source, destination, startIndexnebo length je null.

Příklady

Následující příklad zkopíruje pole do nespravované paměti a pak zkopíruje nespravované pole zpět do spravované paměti.

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

Poznámky

Nespravovaná pole ve stylu C neobsahují informace o hranicích, což brání startIndex ověření parametrů a length . Proto nespravovaná data odpovídající parametru source naplní spravované pole bez ohledu na jeho užitečnost. Před voláním této metody je nutné inicializovat spravované pole s odpovídající velikostí.

Viz také

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

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

Zdroj:

Marshal.cs

Zkopíruje data z jednorozměrného spravovaného 64bitového celočíselného pole se znaménkem na nespravovaný ukazatel paměti.

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)

Parametry

source

Int64[]

Jednorozměrné pole, ze které chcete kopírovat.

startIndex

Int32

Index založený na nule ve zdrojovém poli, kde by mělo být kopírování zahájeno.

destination

IntPtr

nativeint

Ukazatel paměti, do který chcete zkopírovat.

length

Int32

Počet prvků pole, které se mají zkopírovat.

Výjimky

ArgumentOutOfRangeException

startIndex a length nejsou platné.

ArgumentNullException

source, startIndex, destinationnebo length je null.

Příklady

Následující příklad zkopíruje pole do nespravované paměti a pak zkopíruje nespravované pole zpět do spravované paměti.

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

Poznámky

Pomocí této metody můžete zkopírovat podmnožinu jednorozměrného spravovaného pole do nespravovaného pole ve stylu C.

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

Zdroj:

Marshal.cs

Zkopíruje data z jednorozměrného spravovaného 32bitového celočíselného pole se znaménkem do nespravovaného ukazatele paměti.

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)

Parametry

source

Int32[]

Jednorozměrné pole, ze které chcete kopírovat.

startIndex

Int32

Index založený na nule ve zdrojovém poli, kde by mělo být kopírování zahájeno.

destination

IntPtr

nativeint

Ukazatel paměti, do který chcete zkopírovat.

length

Int32

Počet prvků pole, které se mají zkopírovat.

Výjimky

ArgumentOutOfRangeException

startIndex a length nejsou platné.

ArgumentNullException

startIndex nebo length je null.

Příklady

Následující příklad zkopíruje pole do nespravované paměti a pak zkopíruje nespravované pole zpět do spravované paměti.

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

Poznámky

Pomocí této metody můžete zkopírovat podmnožinu jednorozměrného spravovaného pole do nespravovaného pole ve stylu C.

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

Zdroj:

Marshal.cs

Zkopíruje data z jednorozměrného spravovaného 16bitového celočíselného pole se znaménkem na nespravovaný ukazatel paměti.

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)

Parametry

source

Int16[]

Jednorozměrné pole, ze které chcete kopírovat.

startIndex

Int32

Index založený na nule ve zdrojovém poli, kde by mělo být kopírování zahájeno.

destination

IntPtr

nativeint

Ukazatel paměti, do který chcete zkopírovat.

length

Int32

Počet prvků pole, které se mají zkopírovat.

Výjimky

ArgumentOutOfRangeException

startIndex a length nejsou platné.

ArgumentNullException

source, startIndex, destinationnebo length je null.

Příklady

Následující příklad zkopíruje pole do nespravované paměti a pak zkopíruje nespravované pole zpět do spravované paměti.

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

Poznámky

Pomocí této metody můžete zkopírovat podmnožinu jednorozměrného spravovaného pole do nespravovaného pole ve stylu C.

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

Zdroj:

Marshal.cs

Zkopíruje data z jednorozměrného spravovaného číselného pole s plovoucí desetinou čárkou s dvojitou přesností na nespravovaný ukazatel paměti.

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)

Parametry

source

Double[]

Jednorozměrné pole, ze které chcete kopírovat.

startIndex

Int32

Index založený na nule ve zdrojovém poli, kde by mělo být kopírování zahájeno.

destination

IntPtr

nativeint

Ukazatel paměti, do který chcete zkopírovat.

length

Int32

Počet prvků pole, které se mají zkopírovat.

Výjimky

ArgumentOutOfRangeException

startIndex a length nejsou platné.

ArgumentNullException

source, startIndex, destinationnebo length je null.

Příklady

Následující příklad zkopíruje pole do nespravované paměti a pak zkopíruje nespravované pole zpět do spravované paměti.

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

Poznámky

Pomocí této metody můžete zkopírovat podmnožinu jednorozměrného spravovaného pole do nespravovaného pole ve stylu C.

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

Zdroj:

Marshal.cs

Zkopíruje data z jednorozměrného spravovaného pole znaků do nespravovaného ukazatele paměti.

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)

Parametry

source

Char[]

Jednorozměrné pole, ze které chcete kopírovat.

startIndex

Int32

Index založený na nule ve zdrojovém poli, kde by mělo být kopírování zahájeno.

destination

IntPtr

nativeint

Ukazatel paměti, do který chcete zkopírovat.

length

Int32

Počet prvků pole, které se mají zkopírovat.

Výjimky

ArgumentOutOfRangeException

startIndex a length nejsou platné.

ArgumentNullException

startIndex, destinationnebo length je null.

Příklady

Následující příklad zkopíruje pole do nespravované paměti a pak zkopíruje nespravované pole zpět do spravované paměti.

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

Poznámky

Pomocí této metody můžete zkopírovat podmnožinu jednorozměrného spravovaného pole do nespravovaného pole ve stylu C.

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

Zdroj:

Marshal.cs

Zkopíruje data z nespravovaného ukazatele paměti do spravovaného pole znaků.

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)

Parametry

source

IntPtr

nativeint

Ukazatel paměti, ze které chcete kopírovat.

destination

Char[]

Pole, do které chcete kopírovat.

startIndex

Int32

Index založený na nule v cílovém poli, kde by mělo být kopírování zahájeno.

length

Int32

Počet prvků pole, které se mají zkopírovat.

Výjimky

ArgumentNullException

source, destination, startIndexnebo length je null.

Příklady

Následující příklad zkopíruje pole do nespravované paměti a pak zkopíruje nespravované pole zpět do spravované paměti.

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

Poznámky

Nespravovaná pole ve stylu C neobsahují informace o hranicích, což brání startIndex ověření parametrů a length . Proto nespravovaná data odpovídající parametru source naplní spravované pole bez ohledu na jeho užitečnost. Před voláním této metody je nutné inicializovat spravované pole s odpovídající velikostí.

Viz také

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

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

Zdroj:

Marshal.cs

Zkopíruje data z jednorozměrného spravovaného 8bitového celočíselného pole bez znaménka do nespravovaného ukazatele paměti.

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)

Parametry

source

Byte[]

Jednorozměrné pole, ze které chcete kopírovat.

startIndex

Int32

Index založený na nule ve zdrojovém poli, kde by mělo být kopírování zahájeno.

destination

IntPtr

nativeint

Ukazatel paměti, do který chcete zkopírovat.

length

Int32

Počet prvků pole, které se mají zkopírovat.

Výjimky

ArgumentOutOfRangeException

startIndex a length nejsou platné.

ArgumentNullException

source, startIndex, destinationnebo length je null.

Příklady

Následující příklad zkopíruje pole do nespravované paměti pomocí Copy(Byte[], Int32, IntPtr, Int32) přetížení a pak zkopíruje nespravované pole zpět do spravované paměti pomocí Copy(IntPtr, Byte[], Int32, Int32) přetížení.

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

Poznámky

Pomocí této metody můžete zkopírovat podmnožinu jednorozměrného spravovaného pole do nespravovaného pole ve stylu C.