Marshal.Copy Método

Referência

Definição

Namespace:: System.Runtime.InteropServices

Assembly:: System.Runtime.InteropServices.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Copia dados de uma matriz gerenciada para um ponteiro de memória não gerenciada ou de um ponteiro de memória não gerenciada para uma matriz gerenciada.

Sobrecargas

Copy(Single[], Int32, IntPtr, Int32)	Copia os dados de uma matriz de número de ponto flutuante de precisão simples unidimensional gerenciada para um ponteiro de memória não gerenciada.
Copy(IntPtr, Single[], Int32, Int32)	Copia os dados de um ponteiro de memória não gerenciada para uma matriz de número de ponto flutuante de precisão simples gerenciada.
Copy(IntPtr, IntPtr[], Int32, Int32)	Copia os dados de um ponteiro de memória não gerenciada em uma matriz gerenciada IntPtr.
Copy(IntPtr, Int64[], Int32, Int32)	Copia os dados de um ponteiro de memória não gerenciada em uma matriz gerenciada de inteiro com sinal de 64 bits.
Copy(IntPtr, Int32[], Int32, Int32)	Copia os dados de um ponteiro de memória não gerenciado em uma matriz gerenciada de inteiro com sinal de 32 bits.
Copy(IntPtr, Int16[], Int32, Int32)	Copia os dados de um ponteiro de memória não gerenciada em uma matriz gerenciada de inteiro com sinal de 16 bits.
Copy(IntPtr, Double[], Int32, Int32)	Copia os dados de um ponteiro de memória não gerenciada para uma matriz de número de ponto flutuante de precisão dupla gerenciada.
Copy(IntPtr[], Int32, IntPtr, Int32)	Copia os dados de uma matriz gerenciada unidimensional IntPtr para um ponteiro de memória não gerenciado.
Copy(IntPtr, Byte[], Int32, Int32)	Copia os dados de um ponteiro de memória não gerenciada para uma matriz gerenciada de inteiro sem sinal de 8 bits.
Copy(Int64[], Int32, IntPtr, Int32)	Copia os dados de uma matriz de inteiro com sinal unidimensional de 64 bits para um ponteiro de memória não gerenciada.
Copy(Int32[], Int32, IntPtr, Int32)	Copia os dados de uma matriz unidimensional de inteiro com sinal de 32 bits para um ponteiro de memória não gerenciada.
Copy(Int16[], Int32, IntPtr, Int32)	Copia os dados de uma matriz de inteiro com sinal unidimensional de 16 bits para um ponteiro de memória não gerenciada.
Copy(Double[], Int32, IntPtr, Int32)	Copia os dados de uma matriz de número de ponto flutuante de precisão dupla unidimensional gerenciada para um ponteiro de memória não gerenciada.
Copy(Char[], Int32, IntPtr, Int32)	Copia os dados de uma matriz de caracteres gerenciada unidimensional para um ponteiro de memória não gerenciada.
Copy(IntPtr, Char[], Int32, Int32)	Copia os dados de um ponteiro de memória não gerenciada em uma matriz gerenciada de caracteres.
Copy(Byte[], Int32, IntPtr, Int32)	Copia os dados de uma matriz de inteiro sem sinal unidimensional de 8 bits para um ponteiro de memória não gerenciado.

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de uma matriz de número de ponto flutuante de precisão simples unidimensional gerenciada para um ponteiro de memória não gerenciada.

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)

Parâmetros

source: Single[]

A matriz unidimensional a ser copiada.

startIndex: Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.

destination: IntPtr
nativeint

O ponteiro de memória para o qual copiar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentOutOfRangeException

startIndex e length não são válidos.

ArgumentNullException

source, startIndex, destination ou length é null.

Comentários

Você pode usar esse método para copiar um subconjunto de uma matriz gerenciada unidimensional para uma matriz de estilo C não gerenciada.

Aplica-se a

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de um ponteiro de memória não gerenciada para uma matriz de número de ponto flutuante de precisão simples gerenciada.

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)

Parâmetros

source: IntPtr
nativeint

O ponteiro de memória do qual copiar.

destination: Single[]

A matriz para a qual copiar.

startIndex: Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentNullException

source, destination, startIndex ou length é null.

Comentários

Matrizes de estilo C não gerenciadas não contêm informações de limites, o que impede que os startIndex parâmetros e length sejam validados. Assim, os dados não gerenciados correspondentes ao source parâmetro preenchem a matriz gerenciada, independentemente de sua utilidade. Você deve inicializar a matriz gerenciada com o tamanho apropriado antes de chamar esse método.

Confira também

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

Aplica-se a

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de um ponteiro de memória não gerenciada em uma matriz gerenciada 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)

Parâmetros

source: IntPtr
nativeint

O ponteiro de memória do qual copiar.

destination: IntPtr[]

nativeint[]

A matriz para a qual copiar.

startIndex: Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentNullException

source, destination, startIndex ou length é null.

Comentários

Matrizes de estilo C não gerenciadas não contêm informações de limites, o que impede que os startIndex parâmetros e length sejam validados. Portanto, os dados não gerenciados que correspondem ao source parâmetro preenchem a matriz gerenciada, independentemente de sua utilidade. Você deve inicializar a matriz gerenciada com o tamanho apropriado antes de chamar o Marshal.Copy método .

Aplica-se a

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de um ponteiro de memória não gerenciada em uma matriz gerenciada de inteiro com sinal de 64 bits.

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)

Parâmetros

source: IntPtr
nativeint

O ponteiro de memória do qual copiar.

destination: Int64[]

A matriz para a qual copiar.

startIndex: Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentNullException

source, destination, startIndex ou length é null.

Exemplos

O exemplo a seguir copia uma matriz para a memória não gerenciada e copia a matriz não gerenciada de volta para a memória gerenciada.

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

Comentários

Matrizes de estilo C não gerenciadas não contêm informações de limites, o que impede que os startIndex parâmetros e length sejam validados. Assim, os dados não gerenciados correspondentes aosource parâmetro preenchem a matriz gerenciada, independentemente de sua utilidade. Você deve inicializar a matriz gerenciada com o tamanho apropriado antes de chamar esse método.

Confira também

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

Aplica-se a

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de um ponteiro de memória não gerenciado em uma matriz gerenciada de inteiro com sinal de 32 bits.

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)

Parâmetros

source: IntPtr
nativeint

O ponteiro de memória do qual copiar.

destination: Int32[]

A matriz para a qual copiar.

startIndex: Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentNullException

source, destination, startIndex ou length é null.

Exemplos

O exemplo a seguir copia uma matriz para a memória não gerenciada e copia a matriz não gerenciada de volta para a memória gerenciada.

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

Comentários

Confira também

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

Aplica-se a

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de um ponteiro de memória não gerenciada em uma matriz gerenciada de inteiro com sinal de 16 bits.

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)

Parâmetros

source: IntPtr
nativeint

O ponteiro de memória do qual copiar.

destination: Int16[]

A matriz para a qual copiar.

startIndex: Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentNullException

source, destination, startIndex ou length é null.

Exemplos

O exemplo a seguir copia uma matriz para a memória não gerenciada e copia a matriz não gerenciada de volta para a memória gerenciada.

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

Comentários

Confira também

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

Aplica-se a

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de um ponteiro de memória não gerenciada para uma matriz de número de ponto flutuante de precisão dupla gerenciada.

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)

Parâmetros

source: IntPtr
nativeint

O ponteiro de memória do qual copiar.

destination: Double[]

A matriz para a qual copiar.

startIndex: Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentNullException

source, destination, startIndex ou length é null.

Exemplos

O exemplo a seguir copia uma matriz para a memória não gerenciada e copia a matriz não gerenciada de volta para a memória gerenciada.

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

Comentários

Matrizes de estilo C não gerenciadas não contêm informações de limites, o que impede que os startIndex parâmetros e length sejam validados. Assim, os dados não gerenciados correspondentes ao source parâmetro preenchem a matriz gerenciada independentemente de sua utilidade. Você deve inicializar a matriz gerenciada com o tamanho apropriado antes de chamar esse método.

Confira também

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

Aplica-se a

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de uma matriz gerenciada unidimensional IntPtr para um ponteiro de memória não gerenciado.

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)

Parâmetros

source: IntPtr[]

nativeint[]

A matriz unidimensional a ser copiada.

startIndex: Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.

destination: IntPtr
nativeint

O ponteiro de memória para o qual copiar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentNullException

source, destination, startIndex ou length é null.

Comentários

Você pode usar esse método para copiar um subconjunto de uma matriz gerenciada IntPtr unidimensional para uma matriz de estilo C não gerenciada.

Aplica-se a

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de um ponteiro de memória não gerenciada para uma matriz gerenciada de inteiro sem sinal de 8 bits.

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)

Parâmetros

source: IntPtr
nativeint

O ponteiro de memória do qual copiar.

destination: Byte[]

A matriz para a qual copiar.

startIndex: Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentNullException

source, destination, startIndex ou length é null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e copia a matriz não gerenciada de volta para a memória gerenciada.

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

Comentários

Matrizes de estilo C não gerenciadas não contêm informações de limites, o que impede que os startIndex parâmetros e length sejam validados. Assim, os dados não gerenciados correspondentes ao source parâmetro preenchem a matriz gerenciada independentemente de sua utilidade. Você deve inicializar a matriz gerenciada com o tamanho apropriado antes de chamar esse método.

Confira também

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

Aplica-se a

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de uma matriz de inteiro com sinal unidimensional de 64 bits para um ponteiro de memória não gerenciada.

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)

Parâmetros

source: Int64[]

A matriz unidimensional a ser copiada.

startIndex: Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.

destination: IntPtr
nativeint

O ponteiro de memória para o qual copiar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentOutOfRangeException

startIndex e length não são válidos.

ArgumentNullException

source, startIndex, destination ou length é null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e copia a matriz não gerenciada de volta para a memória gerenciada.

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

Comentários

Você pode usar esse método para copiar um subconjunto de uma matriz gerenciada unidimensional para uma matriz de estilo C não gerenciada.

Aplica-se a

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de uma matriz unidimensional de inteiro com sinal de 32 bits para um ponteiro de memória não gerenciada.

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)

Parâmetros

source: Int32[]

A matriz unidimensional a ser copiada.

startIndex: Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.

destination: IntPtr
nativeint

O ponteiro de memória para o qual copiar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentOutOfRangeException

startIndex e length não são válidos.

ArgumentNullException

startIndex ou length é null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e copia a matriz não gerenciada de volta para a memória gerenciada.

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

Comentários

Você pode usar esse método para copiar um subconjunto de uma matriz gerenciada unidimensional para uma matriz de estilo C não gerenciada.

Aplica-se a

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de uma matriz de inteiro com sinal unidimensional de 16 bits para um ponteiro de memória não gerenciada.

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)

Parâmetros

source: Int16[]

A matriz unidimensional a ser copiada.

startIndex: Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.

destination: IntPtr
nativeint

O ponteiro de memória para o qual copiar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentOutOfRangeException

startIndex e length não são válidos.

ArgumentNullException

source, startIndex, destination ou length é null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e copia a matriz não gerenciada de volta para a memória gerenciada.

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

Comentários

Você pode usar esse método para copiar um subconjunto de uma matriz gerenciada unidimensional para uma matriz de estilo C não gerenciada.

Aplica-se a

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de uma matriz de número de ponto flutuante de precisão dupla unidimensional gerenciada para um ponteiro de memória não gerenciada.

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)

Parâmetros

source: Double[]

A matriz unidimensional a ser copiada.

startIndex: Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.

destination: IntPtr
nativeint

O ponteiro de memória para o qual copiar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentOutOfRangeException

startIndex e length não são válidos.

ArgumentNullException

source, startIndex, destination ou length é null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e copia a matriz não gerenciada de volta para a memória gerenciada.

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

Comentários

Você pode usar esse método para copiar um subconjunto de uma matriz gerenciada unidimensional para uma matriz de estilo C não gerenciada.

Aplica-se a

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de uma matriz de caracteres gerenciada unidimensional para um ponteiro de memória não gerenciada.

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)

Parâmetros

source: Char[]

A matriz unidimensional a ser copiada.

startIndex: Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.

destination: IntPtr
nativeint

O ponteiro de memória para o qual copiar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentOutOfRangeException

startIndex e length não são válidos.

ArgumentNullException

startIndex, destination ou length é null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e copia a matriz não gerenciada de volta para a memória gerenciada.

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

Comentários

Você pode usar esse método para copiar um subconjunto de uma matriz gerenciada unidimensional para uma matriz de estilo C não gerenciada.

Aplica-se a

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de um ponteiro de memória não gerenciada em uma matriz gerenciada de caracteres.

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)

Parâmetros

source: IntPtr
nativeint

O ponteiro de memória do qual copiar.

destination: Char[]

A matriz para a qual copiar.

startIndex: Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentNullException

source, destination, startIndex ou length é null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e copia a matriz não gerenciada de volta para a memória gerenciada.

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

Comentários

Matrizes de estilo C não gerenciadas não contêm informações de limites, o que impede que os startIndex parâmetros e length sejam validados. Assim, os dados não gerenciados correspondentes ao source parâmetro preenchem a matriz gerenciada independentemente de sua utilidade. Você deve inicializar a matriz gerenciada com o tamanho apropriado antes de chamar esse método.

Confira também

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

Aplica-se a

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

Origem:: Marshal.cs

Origem:: Marshal.cs

Origem:: Marshal.cs

Copia os dados de uma matriz de inteiro sem sinal unidimensional de 8 bits para um ponteiro de memória não gerenciado.

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)

Parâmetros

source: Byte[]

A matriz unidimensional a ser copiada.

startIndex: Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.

destination: IntPtr
nativeint

O ponteiro de memória para o qual copiar.

length: Int32

O número de elementos da matriz a copiar.

Atributos: SecurityCriticalAttribute

Exceções

ArgumentOutOfRangeException

startIndex e length não são válidos.

ArgumentNullException

source, startIndex, destination ou length é null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada usando a Copy(Byte[], Int32, IntPtr, Int32) sobrecarga e copia a matriz não gerenciada de volta para a memória gerenciada usando a Copy(IntPtr, Byte[], Int32, Int32) sobrecarga.

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

Comentários

Você pode usar esse método para copiar um subconjunto de uma matriz gerenciada unidimensional para uma matriz de estilo C não gerenciada.

Aplica-se a