Marshal.Copy 方法

定義

命名空間:: System.Runtime.InteropServices

組件:: mscorlib.dll, System.Runtime.InteropServices.dll

組件:: netstandard.dll, System.Runtime.InteropServices.dll

組件:: System.Runtime.InteropServices.dll

組件:: mscorlib.dll

組件:: netstandard.dll

重要

部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。

將資料從受管理陣列複製到非受管理的記憶體指標，或從未受管理的記憶體指標複製到受管理陣列。

多載

名稱	Description
Copy(Single[], Int32, IntPtr, Int32)	將一維、受管理的單精度浮點數陣列資料複製到未管理的記憶體指標。
Copy(IntPtr, Single[], Int32, Int32)	將資料從未管理的記憶體指標複製到一個受管理的單精度浮點數陣列。
Copy(IntPtr, IntPtr[], Int32, Int32)	將資料從未管理的記憶體指標複製到受管理 IntPtr 陣列。
Copy(IntPtr, Int64[], Int32, Int32)	將資料從未管理的記憶體指標複製到一個受管理的 64 位元有號整數陣列。
Copy(IntPtr, Int32[], Int32, Int32)	將資料從未管理的記憶體指標複製到一個管理型 32 位元有號整數陣列。
Copy(IntPtr, Int16[], Int32, Int32)	從未管理的記憶體指標複製資料到一個受管理的 16 位元有號整數陣列。
Copy(IntPtr, Double[], Int32, Int32)	將資料從未管理的記憶體指標複製到受管理的雙精度浮點數陣列。
Copy(IntPtr[], Int32, IntPtr, Int32)	將一維受管理 IntPtr 陣列的資料複製到未受管理的記憶體指標。
Copy(IntPtr, Byte[], Int32, Int32)	從未管理的記憶體指標複製資料至一個受管理的 8 位元無符號整數陣列。
Copy(Int64[], Int32, IntPtr, Int32)	將一維、受管理的 64 位元有號整數陣列資料複製到未管理的記憶體指標。
Copy(Int32[], Int32, IntPtr, Int32)	將一維管理的 32 位元有號整數陣列資料複製到未管理的記憶體指標。
Copy(Int16[], Int32, IntPtr, Int32)	將一維、受管理的 16 位元有號整數陣列的資料複製到未管理的記憶體指標。
Copy(Double[], Int32, IntPtr, Int32)	將一維、受管理的雙精度浮點數陣列資料複製到未受管理的記憶體指標。
Copy(Char[], Int32, IntPtr, Int32)	將一維受管理字元陣列的資料複製到未受管理的記憶體指標。
Copy(IntPtr, Char[], Int32, Int32)	從未管理的記憶體指標複製資料到受管理字元陣列。
Copy(Byte[], Int32, IntPtr, Int32)	將一維、受管理的 8 位元無符號整數陣列的資料複製到未受管理的記憶體指標。

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

將一維、受管理的單精度浮點數陣列資料複製到未管理的記憶體指標。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : single[] * int * nativeint * int -> unit

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

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

參數

source: Single[]

一維陣列，要複製。

startIndex: Int32

來源陣列中以零為基礎的索引，應該從這裡開始複製。

destination: IntPtr
nativeint

要複製的記憶體指標。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentOutOfRangeException

startIndex 且 length 不成立。

ArgumentNullException

source， startIndex，， destination或 length 是 null。

備註

你可以用這個方法將一維管理陣列的子集複製到一個未管理的 C 風格陣列。

適用於

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

將資料從未管理的記憶體指標複製到一個受管理的單精度浮點數陣列。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : nativeint * single[] * int * int -> unit

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

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

參數

source: IntPtr
nativeint

是要複製的記憶指標。

destination: Single[]

要複製到的陣列。

startIndex: Int32

目標陣列中以零為基礎的索引，應該從這裡開始複製。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentNullException

source， destination，， startIndex或 length 是 null。

備註

未管理的 C 風格陣列不包含邊界資訊，導致 startIndex 和 length 參數無法被驗證。因此，對應參數 source 的非管理資料會被填充到受管理陣列中，無論其實用性如何。你必須先以適當大小初始化管理陣列，才能呼叫此方法。

另請參閱

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

適用於

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

將資料從未管理的記憶體指標複製到受管理 IntPtr 陣列。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : nativeint * nativeint[] * int * int -> unit

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

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

參數

source: IntPtr
nativeint

是要複製的記憶指標。

destination: IntPtr[]

nativeint[]

要複製到的陣列。

startIndex: Int32

目標陣列中以零為基礎的索引，應該從這裡開始複製。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentNullException

source， destination，， startIndex或 length 是 null。

備註

未管理的 C 風格陣列不包含邊界資訊，導致 startIndex 和 length 參數無法被驗證。因此，對應參數 source 的非管理資料會被填充到受管理陣列中，無論其實用性如何。你必須先以適當大小初始化管理陣列，然後再呼叫該 Marshal.Copy 方法。

適用於

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

將資料從未管理的記憶體指標複製到一個受管理的 64 位元有號整數陣列。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : nativeint * int64[] * int * int -> unit

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

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

參數

source: IntPtr
nativeint

是要複製的記憶指標。

destination: Int64[]

要複製到的陣列。

startIndex: Int32

目標陣列中以零為基礎的索引，應該從這裡開始複製。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentNullException

source， destination，， startIndex或 length 是 null。

範例

以下範例將一個陣列複製到非管理記憶體，然後再將該陣列複製回管理記憶體。

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

備註

未管理的 C 風格陣列不包含邊界資訊，導致 startIndex 和 length 參數無法被驗證。因此，對應參數source 的非管理資料會被填充到受管理陣列中，無論其實用性如何。你必須先以適當大小初始化管理陣列，才能呼叫此方法。

另請參閱

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

適用於

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

將資料從未管理的記憶體指標複製到一個管理型 32 位元有號整數陣列。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : nativeint * int[] * int * int -> unit

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

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

參數

source: IntPtr
nativeint

是要複製的記憶指標。

destination: Int32[]

要複製到的陣列。

startIndex: Int32

目標陣列中以零為基礎的索引，應該從這裡開始複製。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentNullException

source， destination，， startIndex或 length 是 null。

範例

以下範例將一個陣列複製到非管理記憶體，然後再將該陣列複製回管理記憶體。

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

備註

另請參閱

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

適用於

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

從未管理的記憶體指標複製資料到一個受管理的 16 位元有號整數陣列。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : nativeint * int16[] * int * int -> unit

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

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

參數

source: IntPtr
nativeint

是要複製的記憶指標。

destination: Int16[]

要複製到的陣列。

startIndex: Int32

目標陣列中以零為基礎的索引，應該從這裡開始複製。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentNullException

source， destination，， startIndex或 length 是 null。

範例

以下範例將一個陣列複製到非管理記憶體，然後再將該陣列複製回管理記憶體。

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

備註

另請參閱

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

適用於

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

將資料從未管理的記憶體指標複製到受管理的雙精度浮點數陣列。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : nativeint * double[] * int * int -> unit

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

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

參數

source: IntPtr
nativeint

是要複製的記憶指標。

destination: Double[]

要複製到的陣列。

startIndex: Int32

目標陣列中以零為基礎的索引，應該從這裡開始複製。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentNullException

source， destination，， startIndex或 length 是 null。

範例

以下範例將一個陣列複製到非管理記憶體，然後再將該陣列複製回管理記憶體。

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

備註

另請參閱

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

適用於

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

將一維受管理 IntPtr 陣列的資料複製到未受管理的記憶體指標。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : nativeint[] * int * nativeint * int -> unit

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

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

參數

source: IntPtr[]

nativeint[]

一維陣列，要複製。

startIndex: Int32

來源陣列中以零為基礎的索引，應該從這裡開始複製。

destination: IntPtr
nativeint

要複製的記憶體指標。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentNullException

source， destination，， startIndex或 length 是 null。

備註

你可以用這個方法將一維管理 IntPtr 陣列的子集複製到一個未管理的 C 風格陣列。

適用於

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

從未管理的記憶體指標複製資料至一個受管理的 8 位元無符號整數陣列。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : nativeint * byte[] * int * int -> unit

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

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

參數

source: IntPtr
nativeint

是要複製的記憶指標。

destination: Byte[]

要複製到的陣列。

startIndex: Int32

目標陣列中以零為基礎的索引，應該從這裡開始複製。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentNullException

source， destination，， startIndex或 length 是 null。

範例

以下範例將一個陣列複製到非管理記憶體，然後再將該陣列複製回管理記憶體。

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

備註

另請參閱

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

適用於

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

將一維、受管理的 64 位元有號整數陣列資料複製到未管理的記憶體指標。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : int64[] * int * nativeint * int -> unit

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

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

參數

source: Int64[]

一維陣列，要複製。

startIndex: Int32

來源陣列中以零為基礎的索引，應該從這裡開始複製。

destination: IntPtr
nativeint

要複製的記憶體指標。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentOutOfRangeException

startIndex 且 length 不成立。

ArgumentNullException

source， startIndex，， destination或 length 是 null。

範例

以下範例將一個陣列複製到非管理記憶體，然後再將該陣列複製回管理記憶體。

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

備註

你可以用這個方法將一維管理陣列的子集複製到一個未管理的 C 風格陣列。

適用於

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

將一維管理的 32 位元有號整數陣列資料複製到未管理的記憶體指標。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : int[] * int * nativeint * int -> unit

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

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

參數

source: Int32[]

一維陣列，要複製。

startIndex: Int32

來源陣列中以零為基礎的索引，應該從這裡開始複製。

destination: IntPtr
nativeint

要複製的記憶體指標。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentOutOfRangeException

startIndex 且 length 不成立。

ArgumentNullException

startIndex 或 length 為 null。

範例

以下範例將一個陣列複製到非管理記憶體，然後再將該陣列複製回管理記憶體。

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

備註

你可以用這個方法將一維管理陣列的子集複製到一個未管理的 C 風格陣列。

適用於

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

將一維、受管理的 16 位元有號整數陣列的資料複製到未管理的記憶體指標。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : int16[] * int * nativeint * int -> unit

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

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

參數

source: Int16[]

一維陣列，要複製。

startIndex: Int32

來源陣列中以零為基礎的索引，應該從這裡開始複製。

destination: IntPtr
nativeint

要複製的記憶體指標。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentOutOfRangeException

startIndex 且 length 不成立。

ArgumentNullException

source， startIndex，， destination或 length 是 null。

範例

以下範例將一個陣列複製到非管理記憶體，然後再將該陣列複製回管理記憶體。

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

備註

你可以用這個方法將一維管理陣列的子集複製到一個未管理的 C 風格陣列。

適用於

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

將一維、受管理的雙精度浮點數陣列資料複製到未受管理的記憶體指標。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : double[] * int * nativeint * int -> unit

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

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

參數

source: Double[]

一維陣列，要複製。

startIndex: Int32

來源陣列中以零為基礎的索引，應該從這裡開始複製。

destination: IntPtr
nativeint

要複製的記憶體指標。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentOutOfRangeException

startIndex 且 length 不成立。

ArgumentNullException

source， startIndex，， destination或 length 是 null。

範例

以下範例將一個陣列複製到非管理記憶體，然後再將該陣列複製回管理記憶體。

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

備註

你可以用這個方法將一維管理陣列的子集複製到一個未管理的 C 風格陣列。

適用於

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

將一維受管理字元陣列的資料複製到未受管理的記憶體指標。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : char[] * int * nativeint * int -> unit

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

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

參數

source: Char[]

一維陣列，要複製。

startIndex: Int32

來源陣列中以零為基礎的索引，應該從這裡開始複製。

destination: IntPtr
nativeint

要複製的記憶體指標。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentOutOfRangeException

startIndex 且 length 不成立。

ArgumentNullException

startIndex，， destination或 length 是 null。

範例

以下範例將一個陣列複製到非管理記憶體，然後再將該陣列複製回管理記憶體。

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

備註

你可以用這個方法將一維管理陣列的子集複製到一個未管理的 C 風格陣列。

適用於

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

從未管理的記憶體指標複製資料到受管理字元陣列。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : nativeint * char[] * int * int -> unit

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

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

參數

source: IntPtr
nativeint

是要複製的記憶指標。

destination: Char[]

要複製到的陣列。

startIndex: Int32

目標陣列中以零為基礎的索引，應該從這裡開始複製。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentNullException

source， destination，， startIndex或 length 是 null。

範例

以下範例將一個陣列複製到非管理記憶體，然後再將該陣列複製回管理記憶體。

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

備註

另請參閱

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

適用於

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

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

來源:: Marshal.cs

將一維、受管理的 8 位元無符號整數陣列的資料複製到未受管理的記憶體指標。

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

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

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

[<System.Security.SecurityCritical>]
static member Copy : byte[] * int * nativeint * int -> unit

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

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

參數

source: Byte[]

一維陣列，要複製。

startIndex: Int32

來源陣列中以零為基礎的索引，應該從這裡開始複製。

destination: IntPtr
nativeint

要複製的記憶體指標。

length: Int32

要複製的陣列元素數量。

屬性: SecurityCriticalAttribute

例外狀況

ArgumentOutOfRangeException

startIndex 且 length 不成立。

ArgumentNullException

source， startIndex，， destination或 length 是 null。

範例

以下範例利用過載將陣列複製到非管理記憶體 Copy(Byte[], Int32, IntPtr, Int32) ，然後再利用過載將非管理陣列複製回管理記憶體 Copy(IntPtr, Byte[], Int32, Int32) 。

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

備註

你可以用這個方法將一維管理陣列的子集複製到一個未管理的 C 風格陣列。

適用於

意見反應

此頁面對您有幫助嗎？