Marshal.Copy Méthode

  • Référence

Définition

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

Copie les données d'un tableau managé vers un pointeur mémoire non managé ou d'un pointeur mémoire non managé vers un tableau managé.

Surcharges

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

Copie des données d'un tableau de nombres à virgule flottante simple précision managé et unidimensionnel vers un pointeur mémoire non managé.
Copy(IntPtr, Single[], Int32, Int32)

Copie des données d'un pointeur mémoire non managé dans un tableau de nombres à virgule flottante simple précision managé.
Copy(IntPtr, IntPtr[], Int32, Int32)

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

Copie des données à partir d'un pointeur mémoire non managé vers un tableau d'entiers 64 bits signés managé.
Copy(IntPtr, Int32[], Int32, Int32)

Copie des données à partir d'un pointeur mémoire non managé vers un tableau d'entiers 32 bits signés managé.
Copy(IntPtr, Int16[], Int32, Int32)

Copie des données à partir d'un pointeur mémoire non managé vers un tableau d'entiers 16 bits signés managé.
Copy(IntPtr, Double[], Int32, Int32)

Copie des données d'un pointeur mémoire non managé dans un tableau de nombres à virgule flottante double précision managé.
Copy(IntPtr[], Int32, IntPtr, Int32)

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

Copie des données d'un pointeur mémoire non managé dans un tableau d'entiers 8 bits non signés managé.
Copy(Int64[], Int32, IntPtr, Int32)

Copie des données à partir d'un tableau d'entiers 64 bits signés managé et unidimensionnel vers un pointeur mémoire non managé.
Copy(Int32[], Int32, IntPtr, Int32)

Copie des données à partir d'un tableau d'entiers 32 bits signés managé et unidimensionnel vers un pointeur mémoire non managé.
Copy(Int16[], Int32, IntPtr, Int32)

Copie des données à partir d'un tableau d'entiers 16 bits signés managé et unidimensionnel vers un pointeur mémoire non managé.
Copy(Double[], Int32, IntPtr, Int32)

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

Copie des données d'un tableau de caractères managé et unidimensionnel vers un pointeur mémoire non managé.
Copy(IntPtr, Char[], Int32, Int32)

Copie des données d'un pointeur mémoire non managé dans un tableau de caractères managé.
Copy(Byte[], Int32, IntPtr, Int32)

Copie des données d'un tableau d'entiers 8 bits non signés managé et unidimensionnel vers un pointeur mémoire non managé.

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

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

Copie des données d'un tableau de nombres à virgule flottante simple précision managé et unidimensionnel vers un pointeur 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 à partir duquel effectuer la copie.

startIndex
Int32

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

destination
IntPtr

nativeint

Pointeur mémoire de destination de la copie.

length
Int32

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

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentOutOfRangeException

startIndex et length ne sont pas valides.

ArgumentNullException

source, startIndex, destination ou length a la valeur 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, Single[], Int32, Int32)

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

Copie des données d'un pointeur mémoire non managé dans un tableau de nombres à virgule flottante simple précision managé.

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 mémoire à partir duquel effectuer la copie.

destination
Single[]

Tableau dans lequel effectuer la copie.

startIndex
Int32

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

length
Int32

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

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndex ou length a la valeur null.

Remarques

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

Voir aussi

S’applique à

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

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

Copie des données d’un pointeur mémoire non managé dans un tableau de IntPtr managé.

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 mémoire à partir duquel effectuer la copie.

destination

IntPtr[]

nativeint[]

Tableau dans lequel effectuer la copie.

startIndex
Int32

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

length
Int32

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

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndex ou length a la valeur null.

Remarques

Les tableaux de style C non managés ne contiennent pas d’informations sur les limites, ce qui empêche la startIndex validation des paramètres et length . Par conséquent, les données non managées qui correspondent au source paramètre remplissent le tableau managé, quelle que soit leur 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)

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

Copie des données à partir d'un pointeur mémoire non managé vers un tableau d'entiers 64 bits signés 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 mémoire à partir duquel effectuer la copie.

destination
Int64[]

Tableau dans lequel effectuer la copie.

startIndex
Int32

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

length
Int32

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

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndex ou length a la valeur null.

Exemples

L’exemple suivant copie un tableau dans la mémoire non managée, puis copie le tableau non managé dans la 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 sur les limites, ce qui empêche la startIndex validation des paramètres et length . Ainsi, les données non managées correspondant au paramètre remplissent lesource tableau managé, quelle que soit leur 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)

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

Copie des données à partir d'un pointeur mémoire non managé vers un tableau d'entiers 32 bits signés 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 mémoire à partir duquel effectuer la copie.

destination
Int32[]

Tableau dans lequel effectuer la copie.

startIndex
Int32

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

length
Int32

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

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndex ou length a la valeur null.

Exemples

L’exemple suivant copie un tableau dans la mémoire non managée, puis copie le tableau non managé dans la 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 sur les limites, ce qui empêche la startIndex validation des paramètres et length . Ainsi, les données non managées correspondant au paramètre remplissent le source tableau managé, quelle que soit leur 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)

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

Copie des données à partir d'un pointeur mémoire non managé vers un tableau d'entiers 16 bits signés 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 mémoire à partir duquel effectuer la copie.

destination
Int16[]

Tableau dans lequel effectuer la copie.

startIndex
Int32

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

length
Int32

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

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndex ou length a la valeur null.

Exemples

L’exemple suivant copie un tableau dans la mémoire non managée, puis copie le tableau non managé dans la 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 sur les limites, ce qui empêche la startIndex validation des paramètres et length . Ainsi, les données non managées correspondant au paramètre remplissent le source tableau managé, quelle que soit leur 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)

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

Copie des données d'un pointeur mémoire non managé dans un tableau de nombres à virgule flottante double précision managé.

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 mémoire à partir duquel effectuer la copie.

destination
Double[]

Tableau dans lequel effectuer la copie.

startIndex
Int32

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

length
Int32

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

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndex ou length a la valeur null.

Exemples

L’exemple suivant copie un tableau dans la mémoire non managée, puis copie le tableau non managé dans la 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 sur les limites, ce qui empêche la startIndex validation des paramètres et length . Ainsi, les données non managées correspondant au paramètre remplit le source tableau managé, quelle que soit 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, IntPtr, Int32)

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

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

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 à partir duquel effectuer la copie.

startIndex
Int32

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

destination
IntPtr

nativeint

Pointeur mémoire de destination de la copie.

length
Int32

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

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndex ou length a la valeur null.

Remarques

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

S’applique à

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

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

Copie des données d'un pointeur mémoire non managé dans un tableau d'entiers 8 bits non signés 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 mémoire à partir duquel effectuer la copie.

destination
Byte[]

Tableau dans lequel effectuer la copie.

startIndex
Int32

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

length
Int32

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

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndex ou length a la valeur null.

Exemples

L’exemple suivant copie un tableau dans la mémoire non managée, puis copie le tableau non managé dans la 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 de limites, ce qui empêche la startIndex validation des paramètres et length . Ainsi, les données non managées correspondant au paramètre remplit le source tableau managé, quelle que soit 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)

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

Copie des données à partir d'un tableau d'entiers 64 bits signés managé et unidimensionnel vers un pointeur 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 à partir duquel effectuer la copie.

startIndex
Int32

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

destination
IntPtr

nativeint

Pointeur mémoire de destination de la copie.

length
Int32

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

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentOutOfRangeException

startIndex et length ne sont pas valides.

ArgumentNullException

source, startIndex, destination ou length a la valeur null.

Exemples

L’exemple suivant copie un tableau dans la mémoire non managée, puis copie le tableau non managé dans la 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)

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

Copie des données à partir d'un tableau d'entiers 32 bits signés managé et unidimensionnel vers un pointeur 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 à partir duquel effectuer la copie.

startIndex
Int32

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

destination
IntPtr

nativeint

Pointeur mémoire de destination de la copie.

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 dans la mémoire non managée, puis copie le tableau non managé dans la 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)

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

Copie des données à partir d'un tableau d'entiers 16 bits signés managé et unidimensionnel vers un pointeur 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 à partir duquel effectuer la copie.

startIndex
Int32

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

destination
IntPtr

nativeint

Pointeur mémoire de destination de la copie.

length
Int32

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

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentOutOfRangeException

startIndex et length ne sont pas valides.

ArgumentNullException

source, startIndex, destination ou length a la valeur null.

Exemples

L’exemple suivant copie un tableau dans la mémoire non managée, puis copie le tableau non managé dans la 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)

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

Copie des données d'un tableau de nombres à virgule flottante double précision managé et unidimensionnel vers un pointeur 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 à partir duquel effectuer la copie.

startIndex
Int32

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

destination
IntPtr

nativeint

Pointeur mémoire de destination de la copie.

length
Int32

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

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentOutOfRangeException

startIndex et length ne sont pas valides.

ArgumentNullException

source, startIndex, destination ou length a la valeur null.

Exemples

L’exemple suivant copie un tableau dans la mémoire non managée, puis copie le tableau non managé dans la 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(Char[], Int32, IntPtr, Int32)

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

Copie des données d'un tableau de caractères managé et unidimensionnel vers un pointeur 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 à partir duquel effectuer la copie.

startIndex
Int32

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

destination
IntPtr

nativeint

Pointeur mémoire de destination de la copie.

length
Int32

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

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentOutOfRangeException

startIndex et length ne sont pas valides.

ArgumentNullException

startIndex, destination ou length est null.

Exemples

L’exemple suivant copie un tableau dans la mémoire non managée, puis copie le tableau non managé dans la 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(IntPtr, Char[], Int32, Int32)

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

Copie des données d'un pointeur mémoire non managé dans un tableau de caractères managé.

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 mémoire à partir duquel effectuer la copie.

destination
Char[]

Tableau dans lequel effectuer la copie.

startIndex
Int32

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

length
Int32

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

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentNullException

source, destination, startIndex ou length a la valeur null.

Exemples

L’exemple suivant copie un tableau dans la mémoire non managée, puis copie le tableau non managé dans la 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 de limites, ce qui empêche la startIndex validation des paramètres et length . Ainsi, les données non managées correspondant au paramètre remplit le source tableau managé, quelle que soit son utilité. Vous devez initialiser le tableau managé avec la taille appropriée avant d’appeler cette méthode.

Voir aussi

S’applique à

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

Source:
Marshal.cs
Source:
Marshal.cs
Source:
Marshal.cs

Copie des données d'un tableau d'entiers 8 bits non signés managé et unidimensionnel vers un pointeur 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 à partir duquel effectuer la copie.

startIndex
Int32

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

destination
IntPtr

nativeint

Pointeur mémoire de destination de la copie.

length
Int32

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

Attributs
SecurityCriticalAttribute

Exceptions

ArgumentOutOfRangeException

startIndex et length ne sont pas valides.

ArgumentNullException

source, startIndex, destination ou length a la valeur null.

Exemples

L’exemple suivant copie un tableau dans la mémoire non managée à l’aide de la Copy(Byte[], Int32, IntPtr, Int32) surcharge, puis copie le tableau non managé dans 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 à