Marshal.Copy Méthode

Définition

Espace de noms:
System.Runtime.InteropServices
Assemblys:
mscorlib.dll, System.Runtime.InteropServices.dll
Assembly:
mscorlib.dll
Assembly:
System.Runtime.InteropServices.dll
Assembly:
netstandard.dll

Copie les données d’un tableau managé vers un pointeur de mémoire non managé ou à partir d’un pointeur de mémoire non managé vers un tableau managé.

Surcharges

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

Copie les données d’un tableau de nombres à virgule flottante unidimensionnelle managée à virgule flottante à une seule précision vers un pointeur de mémoire non managé.
Copy(IntPtr[], Int32, IntPtr, Int32)

Copie les données d’un tableau managé unidimensionnel vers un pointeur de mémoire non managé IntPtr .
Copy(IntPtr, IntPtr[], Int32, Int32)

Copie les données d’un pointeur de mémoire non managé vers un tableau managé IntPtr .
Copy(IntPtr, Int64[], Int32, Int32)

Copie les données d’un pointeur de mémoire non managé vers un tableau entier signé 64 bits managé.
Copy(IntPtr, Int32[], Int32, Int32)

Copie les données d’un pointeur de mémoire non managé vers un tableau entier signé 32 bits managé.
Copy(IntPtr, Int16[], Int32, Int32)

Copie les données d’un pointeur de mémoire non managé vers un tableau entier signé 16 bits managé.
Copy(IntPtr, Double[], Int32, Int32)

Copie les données d’un pointeur de mémoire non managé vers un tableau de nombres à virgule flottante double précision managée.
Copy(IntPtr, Single[], Int32, Int32)

Copie les données d’un pointeur de mémoire non managé vers un tableau de nombres à virgule flottante simple précision managée.
Copy(IntPtr, Byte[], Int32, Int32)

Copie les données d’un pointeur de mémoire non managé vers un tableau entier non signé 8 bits managé.
Copy(Int64[], Int32, IntPtr, Int32)

Copie les données d’un tableau entier signé 64 bits managé unidimensionnel vers un pointeur de mémoire non managé.
Copy(Int32[], Int32, IntPtr, Int32)

Copie les données d’un tableau entier signé 32 bits managé unidimensionnel vers un pointeur de mémoire non managé.
Copy(Int16[], Int32, IntPtr, Int32)

Copie les données d’un tableau entier signé 16 bits managé à une dimension vers un pointeur de mémoire non managé.
Copy(Double[], Int32, IntPtr, Int32)

Copie les données d’un tableau de nombres à virgule flottante double précision managée unidimensionnel vers un pointeur de mémoire non managé.
Copy(IntPtr, Char[], Int32, Int32)

Copie les données d’un pointeur de mémoire non managé vers un tableau de caractères managés.
Copy(Char[], Int32, IntPtr, Int32)

Copie les données d’un tableau de caractères managés unidimensionnel vers un pointeur de mémoire non managé.
Copy(Byte[], Int32, IntPtr, Int32)

Copie les données d’un tableau entier non signé unidimensionnel managé 8 bits vers un pointeur de mémoire non managé.

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

Copie les données d’un tableau de nombres à virgule flottante unidimensionnelle managée à virgule flottante à une seule précision vers un pointeur de mémoire non managé.

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)

Paramètres

source
Single[]

Tableau unidimensionnel à copier.

startIndex
Int32

Index de base zéro dans le tableau source où la copie doit démarrer.

destination
IntPtr

nativeint

Pointeur de mémoire vers lequel copier.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentOutOfRangeException

startIndex et length ne sont pas valides.

ArgumentNullException

source, startIndex, destinationou length est null.

Remarques

Vous pouvez utiliser cette méthode pour copier un sous-ensemble d’un tableau managé unidimensionnel vers un tableau de style C non managé.

S’applique à

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

Copie les données d’un tableau managé unidimensionnel vers un pointeur de mémoire non managé IntPtr .

public:
 static void Copy(cli::array <IntPtr> ^ source, int startIndex, IntPtr destination, int length);
[System.Security.SecurityCritical]
public static void Copy(IntPtr[] source, int startIndex, IntPtr destination, int length);
public static void Copy(IntPtr[] source, int startIndex, IntPtr destination, int length);
[<System.Security.SecurityCritical>]
static member Copy : nativeint[] * int * nativeint * int -> unit
static member Copy : nativeint[] * int * nativeint * int -> unit
Public Shared Sub Copy (source As IntPtr(), startIndex As Integer, destination As IntPtr, length As Integer)

Paramètres

source

IntPtr[]

nativeint[]

Tableau unidimensionnel à copier.

startIndex
Int32

Index de base zéro dans le tableau source où la copie doit démarrer.

destination
IntPtr

nativeint

Pointeur de mémoire vers lequel copier.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndexou length est null.

Remarques

Vous pouvez utiliser cette méthode pour copier un sous-ensemble d’un tableau managé unidimensionnel vers un tableau de style C non managé IntPtr .

S’applique à

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

Copie les données d’un pointeur de mémoire non managé vers un tableau managé 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)

Paramètres

source
IntPtr

nativeint

Pointeur de mémoire à partir duquel copier.

destination

IntPtr[]

nativeint[]

Tableau vers lequel copier.

startIndex
Int32

Index de base zéro dans le tableau de destination où la copie doit démarrer.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndexou length est null.

Remarques

Les tableaux de style C non managés ne contiennent pas d’informations liées, ce qui empêche la validation des paramètres et length des startIndex paramètres. Par conséquent, les données non managées qui correspondent au paramètre remplissent le source tableau managé indépendamment de son utilité. Vous devez initialiser le tableau managé avec la taille appropriée avant d’appeler la Marshal.Copy méthode.

S’applique à

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

Copie les données d’un pointeur de mémoire non managé vers un tableau entier signé 64 bits managé.

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)

Paramètres

source
IntPtr

nativeint

Pointeur de mémoire à partir duquel copier.

destination
Int64[]

Tableau vers lequel copier.

startIndex
Int32

Index de base zéro dans le tableau de destination où la copie doit démarrer.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndexou length est null.

Exemples

L’exemple suivant copie un tableau en mémoire non managée, puis copie le tableau non managé en mémoire managée.

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

Remarques

Les tableaux de style C non managés ne contiennent pas d’informations liées, ce qui empêche la validation des paramètres et length des startIndex paramètres. Ainsi, les données non managées correspondant ausource paramètre remplissent le tableau managé indépendamment de son utilité. Vous devez initialiser le tableau managé avec la taille appropriée avant d’appeler cette méthode.

Voir aussi

S’applique à

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

Copie les données d’un pointeur de mémoire non managé vers un tableau entier signé 32 bits managé.

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)

Paramètres

source
IntPtr

nativeint

Pointeur de mémoire à partir duquel copier.

destination
Int32[]

Tableau vers lequel copier.

startIndex
Int32

Index de base zéro dans le tableau de destination où la copie doit démarrer.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndexou length est null.

Exemples

L’exemple suivant copie un tableau en mémoire non managée, puis copie le tableau non managé en mémoire managée.

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

Remarques

Les tableaux de style C non managés ne contiennent pas d’informations liées, ce qui empêche la validation des paramètres et length des startIndex paramètres. Ainsi, les données non managées correspondant au source paramètre remplissent le tableau managé indépendamment de son utilité. Vous devez initialiser le tableau managé avec la taille appropriée avant d’appeler cette méthode.

Voir aussi

S’applique à

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

Copie les données d’un pointeur de mémoire non managé vers un tableau entier signé 16 bits managé.

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)

Paramètres

source
IntPtr

nativeint

Pointeur de mémoire à partir duquel copier.

destination
Int16[]

Tableau vers lequel copier.

startIndex
Int32

Index de base zéro dans le tableau de destination où la copie doit démarrer.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndexou length est null.

Exemples

L’exemple suivant copie un tableau en mémoire non managée, puis copie le tableau non managé en mémoire managée.

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

Remarques

Les tableaux de style C non managés ne contiennent pas d’informations liées, ce qui empêche la validation des paramètres et length des startIndex paramètres. Ainsi, les données non managées correspondant au source paramètre remplissent le tableau managé indépendamment de son utilité. Vous devez initialiser le tableau managé avec la taille appropriée avant d’appeler cette méthode.

Voir aussi

S’applique à

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

Copie les données d’un pointeur de mémoire non managé vers un tableau de nombres à virgule flottante double précision managée.

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)

Paramètres

source
IntPtr

nativeint

Pointeur de mémoire à partir duquel copier.

destination
Double[]

Tableau vers lequel copier.

startIndex
Int32

Index de base zéro dans le tableau de destination où la copie doit démarrer.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndexou length est null.

Exemples

L’exemple suivant copie un tableau en mémoire non managée, puis copie le tableau non managé en mémoire managée.

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

Remarques

Les tableaux de style C non managés ne contiennent pas d’informations liées, ce qui empêche la validation des paramètres et length des startIndex paramètres. Ainsi, les données non managées correspondant au source paramètre remplissent le tableau managé indépendamment de son utilité. Vous devez initialiser le tableau managé avec la taille appropriée avant d’appeler cette méthode.

Voir aussi

S’applique à

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

Copie les données d’un pointeur de mémoire non managé vers un tableau de nombres à virgule flottante simple précision managée.

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)

Paramètres

source
IntPtr

nativeint

Pointeur de mémoire à partir duquel copier.

destination
Single[]

Tableau vers lequel copier.

startIndex
Int32

Index de base zéro dans le tableau de destination où la copie doit démarrer.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndexou length est null.

Remarques

Les tableaux de style C non managés ne contiennent pas d’informations liées, ce qui empêche la validation des paramètres et length des startIndex paramètres. Ainsi, les données non managées correspondant au source paramètre remplissent le tableau managé indépendamment de son utilité. Vous devez initialiser le tableau managé avec la taille appropriée avant d’appeler cette méthode.

Voir aussi

S’applique à

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

Copie les données d’un pointeur de mémoire non managé vers un tableau entier non signé 8 bits managé.

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)

Paramètres

source
IntPtr

nativeint

Pointeur de mémoire à partir duquel copier.

destination
Byte[]

Tableau vers lequel copier.

startIndex
Int32

Index de base zéro dans le tableau de destination où la copie doit démarrer.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndexou length est null.

Exemples

L’exemple suivant copie un tableau en mémoire non managée, puis copie le tableau non managé en mémoire managée.

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

Remarques

Les tableaux de style C non managés ne contiennent pas d’informations liées, ce qui empêche la validation des paramètres et length des startIndex paramètres. Ainsi, les données non managées correspondant au source paramètre remplissent le tableau managé indépendamment de son utilité. Vous devez initialiser le tableau managé avec la taille appropriée avant d’appeler cette méthode.

Voir aussi

S’applique à

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

Copie les données d’un tableau entier signé 64 bits managé unidimensionnel vers un pointeur de mémoire non managé.

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)

Paramètres

source
Int64[]

Tableau unidimensionnel à copier.

startIndex
Int32

Index de base zéro dans le tableau source où la copie doit démarrer.

destination
IntPtr

nativeint

Pointeur de mémoire vers lequel copier.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentOutOfRangeException

startIndex et length ne sont pas valides.

ArgumentNullException

source, startIndex, destinationou length est null.

Exemples

L’exemple suivant copie un tableau en mémoire non managée, puis copie le tableau non managé en mémoire managée.

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

Remarques

Vous pouvez utiliser cette méthode pour copier un sous-ensemble d’un tableau managé unidimensionnel vers un tableau de style C non managé.

S’applique à

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

Copie les données d’un tableau entier signé 32 bits managé unidimensionnel vers un pointeur de mémoire non managé.

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)

Paramètres

source
Int32[]

Tableau unidimensionnel à copier.

startIndex
Int32

Index de base zéro dans le tableau source où la copie doit démarrer.

destination
IntPtr

nativeint

Pointeur de mémoire vers lequel copier.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentOutOfRangeException

startIndex et length ne sont pas valides.

ArgumentNullException

startIndex ou length est null.

Exemples

L’exemple suivant copie un tableau en mémoire non managée, puis copie le tableau non managé en mémoire managée.

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

Remarques

Vous pouvez utiliser cette méthode pour copier un sous-ensemble d’un tableau managé unidimensionnel vers un tableau de style C non managé.

S’applique à

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

Copie les données d’un tableau entier signé 16 bits managé à une dimension vers un pointeur de mémoire non managé.

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)

Paramètres

source
Int16[]

Tableau unidimensionnel à copier.

startIndex
Int32

Index de base zéro dans le tableau source où la copie doit démarrer.

destination
IntPtr

nativeint

Pointeur de mémoire vers lequel copier.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentOutOfRangeException

startIndex et length ne sont pas valides.

ArgumentNullException

source, startIndex, destinationou length est null.

Exemples

L’exemple suivant copie un tableau en mémoire non managée, puis copie le tableau non managé en mémoire managée.

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

Remarques

Vous pouvez utiliser cette méthode pour copier un sous-ensemble d’un tableau managé unidimensionnel vers un tableau de style C non managé.

S’applique à

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

Copie les données d’un tableau de nombres à virgule flottante double précision managée unidimensionnel vers un pointeur de mémoire non managé.

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)

Paramètres

source
Double[]

Tableau unidimensionnel à copier.

startIndex
Int32

Index de base zéro dans le tableau source où la copie doit démarrer.

destination
IntPtr

nativeint

Pointeur de mémoire vers lequel copier.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentOutOfRangeException

startIndex et length ne sont pas valides.

ArgumentNullException

source, startIndex, destinationou length est null.

Exemples

L’exemple suivant copie un tableau en mémoire non managée, puis copie le tableau non managé en mémoire managée.

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

Remarques

Vous pouvez utiliser cette méthode pour copier un sous-ensemble d’un tableau managé unidimensionnel vers un tableau de style C non managé.

S’applique à

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

Copie les données d’un pointeur de mémoire non managé vers un tableau de caractères managés.

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)

Paramètres

source
IntPtr

nativeint

Pointeur de mémoire à partir duquel copier.

destination
Char[]

Tableau vers lequel copier.

startIndex
Int32

Index de base zéro dans le tableau de destination où la copie doit démarrer.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndexou length est null.

Exemples

L’exemple suivant copie un tableau en mémoire non managée, puis copie le tableau non managé en mémoire managée.

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

Remarques

Les tableaux de style C non managés ne contiennent pas d’informations liées, ce qui empêche la validation des paramètres et length des startIndex paramètres. Ainsi, les données non managées correspondant au source paramètre remplissent le tableau managé indépendamment de son utilité. Vous devez initialiser le tableau managé avec la taille appropriée avant d’appeler cette méthode.

Voir aussi

S’applique à

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

Copie les données d’un tableau de caractères managés unidimensionnel vers un pointeur de mémoire non managé.

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)

Paramètres

source
Char[]

Tableau unidimensionnel à copier.

startIndex
Int32

Index de base zéro dans le tableau source où la copie doit démarrer.

destination
IntPtr

nativeint

Pointeur de mémoire vers lequel copier.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentOutOfRangeException

startIndex et length ne sont pas valides.

ArgumentNullException

startIndex, destinationou length est null.

Exemples

L’exemple suivant copie un tableau en mémoire non managée, puis copie le tableau non managé en mémoire managée.

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

Remarques

Vous pouvez utiliser cette méthode pour copier un sous-ensemble d’un tableau managé unidimensionnel vers un tableau de style C non managé.

S’applique à

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

Copie les données d’un tableau entier non signé unidimensionnel managé 8 bits vers un pointeur de mémoire non managé.

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)

Paramètres

source
Byte[]

Tableau unidimensionnel à copier.

startIndex
Int32

Index de base zéro dans le tableau source où la copie doit démarrer.

destination
IntPtr

nativeint

Pointeur de mémoire vers lequel copier.

length
Int32

Nombre d’éléments de tableau à copier.

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentOutOfRangeException

startIndex et length ne sont pas valides.

ArgumentNullException

source, startIndex, destinationou length est null.

Exemples

L’exemple suivant copie un tableau en mémoire non managée à l’aide de la Copy(Byte[], Int32, IntPtr, Int32) surcharge, puis copie le tableau non managé vers la mémoire managée à l’aide de la Copy(IntPtr, Byte[], Int32, Int32) surcharge.

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

Remarques

Vous pouvez utiliser cette méthode pour copier un sous-ensemble d’un tableau managé unidimensionnel vers un tableau de style C non managé.

S’applique à