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

Важно!

Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.

Копирует данные из управляемого массива в неуправляемый указатель памяти или из неуправляемого указателя памяти на управляемый массив.

Перегрузки

Имя	Описание
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, , startIndexdestinationили length есть null.

Применяется к

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, , destinationstartIndexили 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, , destinationstartIndexили 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, , destinationstartIndexили 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, , destinationstartIndexили 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, , destinationstartIndexили 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, , destinationstartIndexили 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, , destinationstartIndexили length есть null.

Применяется к

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, , destinationstartIndexили 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, , startIndexdestinationили 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

Применяется к

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

Применяется к

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, , startIndexdestinationили 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(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, , startIndexdestinationили 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(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, или destinationlength есть 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(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, , destinationstartIndexили 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, , startIndexdestinationили 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

Применяется к

Обратная связь

Были ли сведения на этой странице полезными?

Marshal.Copy Метод

Определение

Перегрузки

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

Параметры

Исключения

Комментарии

Применяется к

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

Параметры

Исключения

Комментарии

См. также раздел

Применяется к

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

Параметры

Исключения

Комментарии

Применяется к

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

Параметры

Исключения

Примеры

Комментарии

См. также раздел

Применяется к

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

Параметры

Исключения

Примеры

Комментарии

См. также раздел

Применяется к

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

Параметры

Исключения

Примеры

Комментарии

См. также раздел

Применяется к

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

Параметры

Исключения

Примеры

Комментарии

См. также раздел

Применяется к

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

Параметры

Исключения

Комментарии

Применяется к

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

Параметры

Исключения

Примеры

Комментарии

См. также раздел

Применяется к

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

Параметры

Исключения

Примеры

Комментарии

Применяется к

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

Параметры

Исключения

Примеры

Комментарии

Применяется к

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

Параметры

Исключения

Примеры

Комментарии

Применяется к

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

Параметры

Исключения