Marshal.Copy Метод

Определение

Пространство имен:

System.Runtime.InteropServices

Сборка:

System.Runtime.InteropServices.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

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

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

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

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

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

Параметры

source

Single[]

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

startIndex

Int32

Отсчитываемый от нуля индекс в исходном массиве, с которого начинается копирование.

destination

IntPtr

nativeint

Указатель памяти, в который выполняется копирование.

length

Int32

Число копируемых элементов массива.

Исключения

ArgumentOutOfRangeException

startIndex и length являются недопустимыми.

ArgumentNullException

Параметр source, startIndex, destination или length имеет значение null.

Комментарии

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

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

Исходный код:

Marshal.cs

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

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

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

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

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

Параметры

source

IntPtr

nativeint

Указатель памяти, из которого выполняется копирование.

destination

Single[]

Массив для копирования данных.

startIndex

Int32

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

length

Int32

Число копируемых элементов массива.

Исключения

ArgumentNullException

Параметр source, destination, startIndex или length имеет значение null.

Комментарии

Неуправляемые массивы в стиле C не содержат сведений о границах startIndex , что предотвращает проверку параметров и length . Таким образом, неуправляемые данные, соответствующие параметру source , заполняют управляемый массив независимо от его полезности. Перед вызовом этого метода необходимо инициализировать управляемый массив с соответствующим размером.

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

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

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

Исходный код:

Marshal.cs

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

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

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

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

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

Параметры

source

IntPtr

nativeint

Указатель памяти, из которого выполняется копирование.

destination

IntPtr[]

nativeint[]

Массив для копирования данных.

startIndex

Int32

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

length

Int32

Число копируемых элементов массива.

Исключения

ArgumentNullException

Параметр source, destination, startIndex или length имеет значение null.

Комментарии

Неуправляемые массивы в стиле C не содержат сведений о границах startIndex , что предотвращает проверку параметров и length . Таким образом, неуправляемые данные, соответствующие параметру source , заполняют управляемый массив независимо от его полезности. Перед вызовом метода необходимо инициализировать управляемый Marshal.Copy массив с соответствующим размером.

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

Исходный код:

Marshal.cs

Копирует данные из указателя неуправляемой памяти в одномерный управляемый массив 64-битных целых чисел со знаком.

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

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

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

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

Параметры

source

IntPtr

nativeint

Указатель памяти, из которого выполняется копирование.

destination

Int64[]

Массив для копирования данных.

startIndex

Int32

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

length

Int32

Число копируемых элементов массива.

Исключения

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

Копирует данные из указателя неуправляемой памяти в одномерный управляемый массив 32-битных целых чисел со знаком.

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

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

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

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

Параметры

source

IntPtr

nativeint

Указатель памяти, из которого выполняется копирование.

destination

Int32[]

Массив для копирования данных.

startIndex

Int32

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

length

Int32

Число копируемых элементов массива.

Исключения

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

Комментарии

Неуправляемые массивы в стиле C не содержат сведений о границах startIndex , что предотвращает проверку параметров и length . Таким образом, неуправляемые данные, соответствующие параметру source , заполняют управляемый массив независимо от его полезности. Перед вызовом этого метода необходимо инициализировать управляемый массив с соответствующим размером.

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

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

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

Исходный код:

Marshal.cs

Копирует данные из указателя неуправляемой памяти в одномерный управляемый массив 16-битных целых чисел со знаком.

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

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

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

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

Параметры

source

IntPtr

nativeint

Указатель памяти, из которого выполняется копирование.

destination

Int16[]

Массив для копирования данных.

startIndex

Int32

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

length

Int32

Число копируемых элементов массива.

Исключения

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

Комментарии

Неуправляемые массивы в стиле C не содержат сведений о границах startIndex , что предотвращает проверку параметров и length . Таким образом, неуправляемые данные, соответствующие параметру source , заполняют управляемый массив независимо от его полезности. Перед вызовом этого метода необходимо инициализировать управляемый массив с соответствующим размером.

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

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

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

Исходный код:

Marshal.cs

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

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

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

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

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

Параметры

source

IntPtr

nativeint

Указатель памяти, из которого выполняется копирование.

destination

Double[]

Массив для копирования данных.

startIndex

Int32

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

length

Int32

Число копируемых элементов массива.

Исключения

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

Комментарии

Неуправляемые массивы в стиле C не содержат сведений о границах startIndex , что предотвращает проверку параметров и length . Таким образом, неуправляемые данные, соответствующие параметру source , заполняют управляемый массив независимо от его полезности. Перед вызовом этого метода необходимо инициализировать управляемый массив с соответствующим размером.

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

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

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

Исходный код:

Marshal.cs

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

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

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

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

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

Параметры

source

IntPtr[]

nativeint[]

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

startIndex

Int32

Отсчитываемый от нуля индекс в исходном массиве, с которого начинается копирование.

destination

IntPtr

nativeint

Указатель памяти, в который выполняется копирование.

length

Int32

Число копируемых элементов массива.

Исключения

ArgumentNullException

Параметр source, destination, startIndex или length имеет значение null.

Комментарии

Этот метод можно использовать для копирования подмножества одномерного управляемого IntPtr массива в неуправляемый массив В стиле C.

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

Исходный код:

Marshal.cs

Копирует данные из указателя неуправляемой памяти в одномерный управляемый массив 8-битных целых чисел без знака.

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

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

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

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

Параметры

source

IntPtr

nativeint

Указатель памяти, из которого выполняется копирование.

destination

Byte[]

Массив для копирования данных.

startIndex

Int32

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

length

Int32

Число копируемых элементов массива.

Исключения

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

Комментарии

Неуправляемые массивы в стиле C не содержат сведений о границах startIndex , что предотвращает проверку параметров и length . Таким образом, неуправляемые данные, соответствующие параметру source , заполняют управляемый массив независимо от его полезности. Перед вызовом этого метода необходимо инициализировать управляемый массив с соответствующим размером.

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

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

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

Исходный код:

Marshal.cs

Копирует данные из одномерного управляемого массива 64-битных целых чисел со знаком в указатель неуправляемой памяти.

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

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

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

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

Параметры

source

Int64[]

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

startIndex

Int32

Отсчитываемый от нуля индекс в исходном массиве, с которого начинается копирование.

destination

IntPtr

nativeint

Указатель памяти, в который выполняется копирование.

length

Int32

Число копируемых элементов массива.

Исключения

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

Копирует данные из одномерного управляемого массива 32-битных целых чисел со знаком в указатель неуправляемой памяти.

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

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

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

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

Параметры

source

Int32[]

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

startIndex

Int32

Отсчитываемый от нуля индекс в исходном массиве, с которого начинается копирование.

destination

IntPtr

nativeint

Указатель памяти, в который выполняется копирование.

length

Int32

Число копируемых элементов массива.

Исключения

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

Копирует данные из одномерного управляемого массива 16-битных целых чисел со знаком в указатель неуправляемой памяти.

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

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

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

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

Параметры

source

Int16[]

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

startIndex

Int32

Отсчитываемый от нуля индекс в исходном массиве, с которого начинается копирование.

destination

IntPtr

nativeint

Указатель памяти, в который выполняется копирование.

length

Int32

Число копируемых элементов массива.

Исключения

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

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

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

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

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

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

Параметры

source

Double[]

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

startIndex

Int32

Отсчитываемый от нуля индекс в исходном массиве, с которого начинается копирование.

destination

IntPtr

nativeint

Указатель памяти, в который выполняется копирование.

length

Int32

Число копируемых элементов массива.

Исключения

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

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

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

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

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

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

Параметры

source

Char[]

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

startIndex

Int32

Отсчитываемый от нуля индекс в исходном массиве, с которого начинается копирование.

destination

IntPtr

nativeint

Указатель памяти, в который выполняется копирование.

length

Int32

Число копируемых элементов массива.

Исключения

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

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

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

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

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

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

Параметры

source

IntPtr

nativeint

Указатель памяти, из которого выполняется копирование.

destination

Char[]

Массив для копирования данных.

startIndex

Int32

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

length

Int32

Число копируемых элементов массива.

Исключения

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

Комментарии

Неуправляемые массивы в стиле C не содержат сведений о границах startIndex , что предотвращает проверку параметров и length . Таким образом, неуправляемые данные, соответствующие параметру source , заполняют управляемый массив независимо от его полезности. Перед вызовом этого метода необходимо инициализировать управляемый массив с соответствующим размером.

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

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

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

Исходный код:

Marshal.cs

Копирует данные из одномерного управляемого массива 8-битных целых чисел без знака в указатель неуправляемой памяти.

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

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

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

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

Параметры

source

Byte[]

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

startIndex

Int32

Отсчитываемый от нуля индекс в исходном массиве, с которого начинается копирование.

destination

IntPtr

nativeint

Указатель памяти, в который выполняется копирование.

length

Int32

Число копируемых элементов массива.

Исключения

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.