Marshal.Copy Método

Definição

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.Copies data from a managed array to an unmanaged memory pointer, or from an unmanaged memory pointer to a managed array.

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.Copies data from a one-dimensional, managed single-precision floating-point number array to an unmanaged memory pointer.

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

Copia os dados de uma matriz gerenciada unidimensional IntPtr para um ponteiro de memória não gerenciado.Copies data from a one-dimensional, managed IntPtr array to an unmanaged memory pointer.

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.Copies data from an unmanaged memory pointer to a managed single-precision floating-point number array.

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.Copies data from an unmanaged memory pointer to a managed 64-bit signed integer array.

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.Copies data from an unmanaged memory pointer to a managed 32-bit signed integer array.

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.Copies data from an unmanaged memory pointer to a managed 16-bit signed integer array.

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.Copies data from an unmanaged memory pointer to a managed double-precision floating-point number array.

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

Copia os dados de um ponteiro de memória não gerenciada em uma matriz gerenciada IntPtr.Copies data from an unmanaged memory pointer to a managed IntPtr array.

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.Copies data from an unmanaged memory pointer to a managed 8-bit unsigned integer array.

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.Copies data from a one-dimensional, managed 64-bit signed integer array to an unmanaged memory pointer.

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.Copies data from a one-dimensional, managed 32-bit signed integer array to an unmanaged memory pointer.

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.Copies data from a one-dimensional, managed 16-bit signed integer array to an unmanaged memory pointer.

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

Copia os dados de um ponteiro de memória não gerenciada em uma matriz gerenciada de caracteres.Copies data from an unmanaged memory pointer to a managed character array.

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.Copies data from a one-dimensional, managed double-precision floating-point number array to an unmanaged memory pointer.

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

Copia os dados de uma matriz de caracteres gerenciada unidimensional para um ponteiro de memória não gerenciada.Copies data from a one-dimensional, managed character array to an unmanaged memory pointer.

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.Copies data from a one-dimensional, managed 8-bit unsigned integer array to an unmanaged memory pointer.

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.Copies data from a one-dimensional, managed single-precision floating-point number array to an unmanaged memory pointer.

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);
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.The one-dimensional array to copy from.

startIndex
Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.The zero-based index in the source array where copying should start.

destination
IntPtr

O ponteiro de memória para o qual copiar.The memory pointer to copy to.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

startIndex e length não são válidos.startIndex and length are not valid.

source, startIndex, destination ou length é null.source, startIndex, destination, or length is 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.You can use this method to copy a subset of a one-dimensional managed array to an unmanaged C-style array.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

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

Copia os dados de uma matriz gerenciada unidimensional IntPtr para um ponteiro de memória não gerenciado.Copies data from a one-dimensional, managed IntPtr array to an unmanaged memory pointer.

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);
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[]

A matriz unidimensional a ser copiada.The one-dimensional array to copy from.

startIndex
Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.The zero-based index in the source array where copying should start.

destination
IntPtr

O ponteiro de memória para o qual copiar.The memory pointer to copy to.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

source, destination, startIndex ou length é null.source, destination, startIndex, or length is null.

Comentários

Você pode usar esse método para copiar um subconjunto de uma matriz de IntPtr gerenciada unidimensional para uma matriz de estilo C não gerenciada.You can use this method to copy a subset of a one-dimensional managed IntPtr array to an unmanaged C-style array.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

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.Copies data from an unmanaged memory pointer to a managed single-precision floating-point number array.

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);
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

O ponteiro de memória do qual copiar.The memory pointer to copy from.

destination
Single[]

A matriz para a qual copiar.The array to copy to.

startIndex
Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.The zero-based index in the destination array where copying should start.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

source, destination, startIndex ou length é null.source, destination, startIndex, or length is null.

Comentários

As matrizes não gerenciadas em estilo C não contêm informações associadas, o que impede que os parâmetros startIndex e length sejam validados.Unmanaged, C-style arrays do not contain bounds information, which prevents the startIndex and length parameters from being validated. Assim, os dados não gerenciados que correspondem ao parâmetro source popularão a matriz gerenciada, independentemente de sua utilidade.Thus, the unmanaged data corresponding to the source parameter populates the managed array regardless of its usefulness. Você deve inicializar a matriz gerenciada com o tamanho apropriado antes de chamar esse método.You must initialize the managed array with the appropriate size before calling this method.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

Veja também

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.Copies data from an unmanaged memory pointer to a managed 64-bit signed integer array.

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);
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

O ponteiro de memória do qual copiar.The memory pointer to copy from.

destination
Int64[]

A matriz para a qual copiar.The array to copy to.

startIndex
Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.The zero-based index in the destination array where copying should start.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

source, destination, startIndex ou length é null.source, destination, startIndex, or length is null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e, em seguida, copia a matriz não gerenciada de volta para a memória gerenciada.The following example copies an array to unmanaged memory and then copies the unmanaged array back to managed memory.

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

As matrizes não gerenciadas em estilo C não contêm informações associadas, o que impede que os parâmetros startIndex e length sejam validados.Unmanaged, C-style arrays do not contain bounds information, which prevents the startIndex and length parameters from being validated. Assim, os dados não gerenciados que correspondem ao parâmetrosource popularão a matriz gerenciada, independentemente de sua utilidade.Thus, the unmanaged data corresponding to thesource parameter populates the managed array regardless of its usefulness. Você deve inicializar a matriz gerenciada com o tamanho apropriado antes de chamar esse método.You must initialize the managed array with the appropriate size before calling this method.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

Veja também

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.Copies data from an unmanaged memory pointer to a managed 32-bit signed integer array.

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);
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

O ponteiro de memória do qual copiar.The memory pointer to copy from.

destination
Int32[]

A matriz para a qual copiar.The array to copy to.

startIndex
Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.The zero-based index in the destination array where copying should start.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

source, destination, startIndex ou length é null.source, destination, startIndex, or length is null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e, em seguida, copia a matriz não gerenciada de volta para a memória gerenciada.The following example copies an array to unmanaged memory and then copies the unmanaged array back to managed memory.

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

As matrizes não gerenciadas em estilo C não contêm informações associadas, o que impede que os parâmetros startIndex e length sejam validados.Unmanaged, C-style arrays do not contain bounds information, which prevents the startIndex and length parameters from being validated. Assim, os dados não gerenciados que correspondem ao parâmetro source popularão a matriz gerenciada, independentemente de sua utilidade.Thus, the unmanaged data corresponding to the source parameter populates the managed array regardless of its usefulness. Você deve inicializar a matriz gerenciada com o tamanho apropriado antes de chamar esse método.You must initialize the managed array with the appropriate size before calling this method.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

Veja também

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.Copies data from an unmanaged memory pointer to a managed 16-bit signed integer array.

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);
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

O ponteiro de memória do qual copiar.The memory pointer to copy from.

destination
Int16[]

A matriz para a qual copiar.The array to copy to.

startIndex
Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.The zero-based index in the destination array where copying should start.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

source, destination, startIndex ou length é null.source, destination, startIndex, or length is null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e, em seguida, copia a matriz não gerenciada de volta para a memória gerenciada.The following example copies an array to unmanaged memory and then copies the unmanaged array back to managed memory.

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

As matrizes não gerenciadas em estilo C não contêm informações associadas, o que impede que os parâmetros startIndex e length sejam validados.Unmanaged, C-style arrays do not contain bounds information, which prevents the startIndex and length parameters from being validated. Assim, os dados não gerenciados que correspondem ao parâmetro source popularão a matriz gerenciada, independentemente de sua utilidade.Thus, the unmanaged data corresponding to the source parameter populates the managed array regardless of its usefulness. Você deve inicializar a matriz gerenciada com o tamanho apropriado antes de chamar esse método.You must initialize the managed array with the appropriate size before calling this method.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

Veja também

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.Copies data from an unmanaged memory pointer to a managed double-precision floating-point number array.

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);
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

O ponteiro de memória do qual copiar.The memory pointer to copy from.

destination
Double[]

A matriz para a qual copiar.The array to copy to.

startIndex
Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.The zero-based index in the destination array where copying should start.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

source, destination, startIndex ou length é null.source, destination, startIndex, or length is null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e, em seguida, copia a matriz não gerenciada de volta para a memória gerenciada.The following example copies an array to unmanaged memory and then copies the unmanaged array back to managed memory.

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

As matrizes não gerenciadas em estilo C não contêm informações associadas, o que impede que os parâmetros startIndex e length sejam validados.Unmanaged, C-style arrays do not contain bounds information, which prevents the startIndex and length parameters from being validated. Assim, os dados não gerenciados que correspondem ao parâmetro source popularão a matriz gerenciada, independentemente de sua utilidade.Thus, the unmanaged data corresponding to the source parameter populates the managed array regardless of its usefulness. Você deve inicializar a matriz gerenciada com o tamanho apropriado antes de chamar esse método.You must initialize the managed array with the appropriate size before calling this method.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

Veja também

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

Copia os dados de um ponteiro de memória não gerenciada em uma matriz gerenciada IntPtr.Copies data from an unmanaged memory pointer to a managed IntPtr array.

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);
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

O ponteiro de memória do qual copiar.The memory pointer to copy from.

destination
IntPtr[]

A matriz para a qual copiar.The array to copy to.

startIndex
Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.The zero-based index in the destination array where copying should start.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

source, destination, startIndex ou length é null.source, destination, startIndex, or length is null.

Comentários

As matrizes não gerenciadas em estilo C não contêm informações associadas, o que impede que os parâmetros startIndex e length sejam validados.Unmanaged, C-style arrays do not contain bounds information, which prevents the startIndex and length parameters from being validated. Portanto, os dados não gerenciados que correspondem ao parâmetro source popula a matriz gerenciada, independentemente de sua utilidade.Therefore, the unmanaged data that corresponds to the source parameter populates the managed array regardless of its usefulness. Você deve inicializar a matriz gerenciada com o tamanho apropriado antes de chamar o método Marshal.Copy.You must initialize the managed array with the appropriate size before calling the Marshal.Copy method.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

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.Copies data from an unmanaged memory pointer to a managed 8-bit unsigned integer array.

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);
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

O ponteiro de memória do qual copiar.The memory pointer to copy from.

destination
Byte[]

A matriz para a qual copiar.The array to copy to.

startIndex
Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.The zero-based index in the destination array where copying should start.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

source, destination, startIndex ou length é null.source, destination, startIndex, or length is null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e, em seguida, copia a matriz não gerenciada de volta para a memória gerenciada.The following example copies an array to unmanaged memory and then copies the unmanaged array back to managed memory.

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

As matrizes não gerenciadas em estilo C não contêm informações associadas, o que impede que os parâmetros startIndex e length sejam validados.Unmanaged, C-style arrays do not contain bounds information, which prevents the startIndex and length parameters from being validated. Assim, os dados não gerenciados que correspondem ao parâmetro source popularão a matriz gerenciada, independentemente de sua utilidade.Thus, the unmanaged data corresponding to the source parameter populates the managed array regardless of its usefulness. Você deve inicializar a matriz gerenciada com o tamanho apropriado antes de chamar esse método.You must initialize the managed array with the appropriate size before calling this method.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

Veja também

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.Copies data from a one-dimensional, managed 64-bit signed integer array to an unmanaged memory pointer.

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);
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.The one-dimensional array to copy from.

startIndex
Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.The zero-based index in the source array where copying should start.

destination
IntPtr

O ponteiro de memória para o qual copiar.The memory pointer to copy to.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

startIndex e length não são válidos.startIndex and length are not valid.

source, startIndex, destination ou length é null.source, startIndex, destination, or length is null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e, em seguida, copia a matriz não gerenciada de volta para a memória gerenciada.The following example copies an array to unmanaged memory and then copies the unmanaged array back to managed memory.

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.You can use this method to copy a subset of a one-dimensional managed array to an unmanaged C-style array.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

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.Copies data from a one-dimensional, managed 32-bit signed integer array to an unmanaged memory pointer.

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);
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.The one-dimensional array to copy from.

startIndex
Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.The zero-based index in the source array where copying should start.

destination
IntPtr

O ponteiro de memória para o qual copiar.The memory pointer to copy to.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

startIndex e length não são válidos.startIndex and length are not valid.

startIndex ou length é null.startIndex or length is null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e, em seguida, copia a matriz não gerenciada de volta para a memória gerenciada.The following example copies an array to unmanaged memory and then copies the unmanaged array back to managed memory.

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.You can use this method to copy a subset of a one-dimensional managed array to an unmanaged C-style array.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

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.Copies data from a one-dimensional, managed 16-bit signed integer array to an unmanaged memory pointer.

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);
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.The one-dimensional array to copy from.

startIndex
Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.The zero-based index in the source array where copying should start.

destination
IntPtr

O ponteiro de memória para o qual copiar.The memory pointer to copy to.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

startIndex e length não são válidos.startIndex and length are not valid.

source, startIndex, destination ou length é null.source, startIndex, destination, or length is null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e, em seguida, copia a matriz não gerenciada de volta para a memória gerenciada.The following example copies an array to unmanaged memory and then copies the unmanaged array back to managed memory.

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.You can use this method to copy a subset of a one-dimensional managed array to an unmanaged C-style array.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

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

Copia os dados de um ponteiro de memória não gerenciada em uma matriz gerenciada de caracteres.Copies data from an unmanaged memory pointer to a managed character array.

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);
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

O ponteiro de memória do qual copiar.The memory pointer to copy from.

destination
Char[]

A matriz para a qual copiar.The array to copy to.

startIndex
Int32

O índice baseado em zero na matriz de destino em que a cópia deve iniciar.The zero-based index in the destination array where copying should start.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

source, destination, startIndex ou length é null.source, destination, startIndex, or length is null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e, em seguida, copia a matriz não gerenciada de volta para a memória gerenciada.The following example copies an array to unmanaged memory and then copies the unmanaged array back to managed memory.

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

As matrizes não gerenciadas em estilo C não contêm informações associadas, o que impede que os parâmetros startIndex e length sejam validados.Unmanaged, C-style arrays do not contain bounds information, which prevents the startIndex and length parameters from being validated. Assim, os dados não gerenciados que correspondem ao parâmetro source popularão a matriz gerenciada, independentemente de sua utilidade.Thus, the unmanaged data corresponding to the source parameter populates the managed array regardless of its usefulness. Você deve inicializar a matriz gerenciada com o tamanho apropriado antes de chamar esse método.You must initialize the managed array with the appropriate size before calling this method.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

Veja também

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.Copies data from a one-dimensional, managed double-precision floating-point number array to an unmanaged memory pointer.

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);
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.The one-dimensional array to copy from.

startIndex
Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.The zero-based index in the source array where copying should start.

destination
IntPtr

O ponteiro de memória para o qual copiar.The memory pointer to copy to.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

startIndex e length não são válidos.startIndex and length are not valid.

source, startIndex, destination ou length é null.source, startIndex, destination, or length is null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e, em seguida, copia a matriz não gerenciada de volta para a memória gerenciada.The following example copies an array to unmanaged memory and then copies the unmanaged array back to managed memory.

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.You can use this method to copy a subset of a one-dimensional managed array to an unmanaged C-style array.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

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

Copia os dados de uma matriz de caracteres gerenciada unidimensional para um ponteiro de memória não gerenciada.Copies data from a one-dimensional, managed character array to an unmanaged memory pointer.

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);
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.The one-dimensional array to copy from.

startIndex
Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.The zero-based index in the source array where copying should start.

destination
IntPtr

O ponteiro de memória para o qual copiar.The memory pointer to copy to.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

startIndex e length não são válidos.startIndex and length are not valid.

startIndex, destination ou length é null.startIndex, destination, or length is null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada e, em seguida, copia a matriz não gerenciada de volta para a memória gerenciada.The following example copies an array to unmanaged memory and then copies the unmanaged array back to managed memory.

// 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.You can use this method to copy a subset of a one-dimensional managed array to an unmanaged C-style array.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

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.Copies data from a one-dimensional, managed 8-bit unsigned integer array to an unmanaged memory pointer.

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);
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.The one-dimensional array to copy from.

startIndex
Int32

O índice baseado em zero na matriz de origem em que a cópia deve iniciar.The zero-based index in the source array where copying should start.

destination
IntPtr

O ponteiro de memória para o qual copiar.The memory pointer to copy to.

length
Int32

O número de elementos da matriz a copiar.The number of array elements to copy.

Atributos

Exceções

startIndex e length não são válidos.startIndex and length are not valid.

source, startIndex, destination ou length é null.source, startIndex, destination, or length is null.

Exemplos

O exemplo a seguir copia uma matriz para memória não gerenciada usando a sobrecarga de Copy(Byte[], Int32, IntPtr, Int32) e, em seguida, copia a matriz não gerenciada de volta para a memória gerenciada usando a sobrecarga de Copy(IntPtr, Byte[], Int32, Int32).The following example copies an array to unmanaged memory by using the Copy(Byte[], Int32, IntPtr, Int32) overload, and then copies the unmanaged array back to managed memory by using the Copy(IntPtr, Byte[], Int32, Int32) overload.

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.You can use this method to copy a subset of a one-dimensional managed array to an unmanaged C-style array.

Segurança

SecurityCriticalAttribute
requer confiança total para o chamador imediato.requires full trust for the immediate caller. Este membro não pode ser usado pelo código transparente ou parcialmente confiável.This member cannot be used by partially trusted or transparent code.

Aplica-se a