Marshal.Copy Methode

Definition

Namespace:

System.Runtime.InteropServices

Assembly:

System.Runtime.InteropServices.dll

Kopiert Daten aus einem verwalteten Array in einen nicht verwalteten Speicherzeiger oder aus einem nicht verwalteten Speicherzeiger in ein verwaltetes Array.

Überlädt

Copy(Single[], Int32, IntPtr, Int32)	Kopiert Daten aus einem eindimensionalen, verwalteten Array von Gleitkommazahlen mit einfacher Genauigkeit in einen nicht verwalteten Speicherzeiger.
Copy(IntPtr, Single[], Int32, Int32)	Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes Array von Gleitkommazahlen mit einfacher Genauigkeit.
Copy(IntPtr, IntPtr[], Int32, Int32)	Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes IntPtr-Array.
Copy(IntPtr, Int64[], Int32, Int32)	Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes Array von 64-Bit-Ganzzahlen mit Vorzeichen.
Copy(IntPtr, Int32[], Int32, Int32)	Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes Array von 32-Bit-Ganzzahlen mit Vorzeichen.
Copy(IntPtr, Int16[], Int32, Int32)	Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes Array von 16-Bit-Ganzzahlen mit Vorzeichen.
Copy(IntPtr, Double[], Int32, Int32)	Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes Array von Gleitkommazahlen mit doppelter Genauigkeit.
Copy(IntPtr[], Int32, IntPtr, Int32)	Kopiert Daten aus einem eindimensionalen, verwalteten IntPtr-Array in einen nicht verwalteten Speicherzeiger.
Copy(IntPtr, Byte[], Int32, Int32)	Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes Array von 8-Bit-Ganzzahlen ohne Vorzeichen.
Copy(Int64[], Int32, IntPtr, Int32)	Kopiert Daten aus einem eindimensionalen, verwalteten Array von 64-Bit-Ganzzahlen mit Vorzeichen in einen nicht verwalteten Speicherzeiger.
Copy(Int32[], Int32, IntPtr, Int32)	Kopiert Daten aus einem eindimensionalen, verwalteten Array von 32-Bit-Ganzzahlen mit Vorzeichen in einen nicht verwalteten Speicherzeiger.
Copy(Int16[], Int32, IntPtr, Int32)	Kopiert Daten aus einem eindimensionalen, verwalteten Array von 16-Bit-Ganzzahlen mit Vorzeichen in einen nicht verwalteten Speicherzeiger.
Copy(Double[], Int32, IntPtr, Int32)	Kopiert Daten aus einem eindimensionalen, verwalteten Array von Gleitkommazahlen mit doppelter Genauigkeit in einen nicht verwalteten Speicherzeiger.
Copy(Char[], Int32, IntPtr, Int32)	Kopiert Daten aus einem eindimensionalen, verwalteten Zeichenarray in einen nicht verwalteten Speicherzeiger.
Copy(IntPtr, Char[], Int32, Int32)	Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes Zeichenarray.
Copy(Byte[], Int32, IntPtr, Int32)	Kopiert Daten aus einem eindimensionalen, verwalteten Array von 8-Bit-Ganzzahlen ohne Vorzeichen in einen nicht verwalteten Speicherzeiger.

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

Quelle:

Marshal.cs

Kopiert Daten aus einem eindimensionalen, verwalteten Array von Gleitkommazahlen mit einfacher Genauigkeit in einen nicht verwalteten Speicherzeiger.

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

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

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

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

Parameter

source

Single[]

Das eindimensionale Array, aus dem kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Quellarray, an dem der Kopiervorgang beginnen soll.

destination

IntPtr

nativeint

Der Speicherzeiger, in den kopiert werden soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentOutOfRangeException

startIndex und length sind nicht gültig.

ArgumentNullException

source, startIndex, destination oder length ist null.

Hinweise

Sie können diese Methode verwenden, um eine Teilmenge eines eindimensionalen verwalteten Arrays in ein nicht verwaltetes Array im C-Stil zu kopieren.

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

Quelle:

Marshal.cs

Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes Array von Gleitkommazahlen mit einfacher Genauigkeit.

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

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

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

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

Parameter

source

IntPtr

nativeint

Der Speicherzeiger, aus dem kopiert werden soll.

destination

Single[]

Das Array, in das kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Zielarray, an dem der Kopiervorgang beginnen soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentNullException

source, destination, startIndex oder length ist null.

Hinweise

Nicht verwaltete Arrays im C-Stil enthalten keine Begrenzungsinformationen, wodurch verhindert wird, dass die startIndex Parameter und length überprüft werden. Daher füllen die nicht verwalteten Daten, die dem source Parameter entsprechen, das verwaltete Array unabhängig von seiner Nützlichkeit auf. Sie müssen das verwaltete Array mit der entsprechenden Größe initialisieren, bevor Sie diese Methode aufrufen.

Weitere Informationen

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

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

Quelle:

Marshal.cs

Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes IntPtr-Array.

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

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

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

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

Parameter

source

IntPtr

nativeint

Der Speicherzeiger, aus dem kopiert werden soll.

destination

IntPtr[]

nativeint[]

Das Array, in das kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Zielarray, an dem der Kopiervorgang beginnen soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentNullException

source, destination, startIndex oder length ist null.

Hinweise

Nicht verwaltete Arrays im C-Stil enthalten keine Begrenzungsinformationen, wodurch verhindert wird, dass die startIndex Parameter und length überprüft werden. Daher werden die nicht verwalteten Daten, die dem source Parameter entsprechen, das verwaltete Array unabhängig von seiner Nützlichkeit aufgefüllt. Sie müssen das verwaltete Array mit der entsprechenden Größe initialisieren, bevor Sie die Marshal.Copy -Methode aufrufen.

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

Quelle:

Marshal.cs

Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes Array von 64-Bit-Ganzzahlen mit Vorzeichen.

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

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

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

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

Parameter

source

IntPtr

nativeint

Der Speicherzeiger, aus dem kopiert werden soll.

destination

Int64[]

Das Array, in das kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Zielarray, an dem der Kopiervorgang beginnen soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentNullException

source, destination, startIndex oder length ist null.

Beispiele

Im folgenden Beispiel wird ein Array in den nicht verwalteten Arbeitsspeicher kopiert und dann das nicht verwaltete Array wieder in den verwalteten Arbeitsspeicher kopiert.

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

Hinweise

Nicht verwaltete Arrays im C-Stil enthalten keine Begrenzungsinformationen, wodurch verhindert wird, dass die startIndex Parameter und length überprüft werden. Daher füllen die nicht verwalteten Daten, die demsource Parameter entsprechen, das verwaltete Array unabhängig von seiner Nützlichkeit auf. Sie müssen das verwaltete Array mit der entsprechenden Größe initialisieren, bevor Sie diese Methode aufrufen.

Weitere Informationen

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

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

Quelle:

Marshal.cs

Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes Array von 32-Bit-Ganzzahlen mit Vorzeichen.

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

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

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

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

Parameter

source

IntPtr

nativeint

Der Speicherzeiger, aus dem kopiert werden soll.

destination

Int32[]

Das Array, in das kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Zielarray, an dem der Kopiervorgang beginnen soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentNullException

source, destination, startIndex oder length ist null.

Beispiele

Im folgenden Beispiel wird ein Array in den nicht verwalteten Arbeitsspeicher kopiert und dann das nicht verwaltete Array wieder in den verwalteten Arbeitsspeicher kopiert.

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

Hinweise

Nicht verwaltete Arrays im C-Stil enthalten keine Begrenzungsinformationen, wodurch verhindert wird, dass die startIndex Parameter und length überprüft werden. Daher füllen die nicht verwalteten Daten, die dem source Parameter entsprechen, das verwaltete Array unabhängig von seiner Nützlichkeit auf. Sie müssen das verwaltete Array mit der entsprechenden Größe initialisieren, bevor Sie diese Methode aufrufen.

Weitere Informationen

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

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

Quelle:

Marshal.cs

Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes Array von 16-Bit-Ganzzahlen mit Vorzeichen.

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

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

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

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

Parameter

source

IntPtr

nativeint

Der Speicherzeiger, aus dem kopiert werden soll.

destination

Int16[]

Das Array, in das kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Zielarray, an dem der Kopiervorgang beginnen soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentNullException

source, destination, startIndex oder length ist null.

Beispiele

Im folgenden Beispiel wird ein Array in den nicht verwalteten Arbeitsspeicher kopiert und dann das nicht verwaltete Array wieder in den verwalteten Arbeitsspeicher kopiert.

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

Hinweise

Nicht verwaltete Arrays im C-Stil enthalten keine Begrenzungsinformationen, wodurch verhindert wird, dass die startIndex Parameter und length überprüft werden. Daher füllen die nicht verwalteten Daten, die dem source Parameter entsprechen, das verwaltete Array unabhängig von seiner Nützlichkeit auf. Sie müssen das verwaltete Array mit der entsprechenden Größe initialisieren, bevor Sie diese Methode aufrufen.

Weitere Informationen

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

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

Quelle:

Marshal.cs

Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes Array von Gleitkommazahlen mit doppelter Genauigkeit.

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

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

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

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

Parameter

source

IntPtr

nativeint

Der Speicherzeiger, aus dem kopiert werden soll.

destination

Double[]

Das Array, in das kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Zielarray, an dem der Kopiervorgang beginnen soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentNullException

source, destination, startIndex oder length ist null.

Beispiele

Im folgenden Beispiel wird ein Array in den nicht verwalteten Arbeitsspeicher kopiert und dann das nicht verwaltete Array wieder in den verwalteten Arbeitsspeicher kopiert.

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

Hinweise

Nicht verwaltete Arrays im C-Stil enthalten keine Begrenzungsinformationen, wodurch verhindert wird, dass die startIndex Parameter und length überprüft werden. Daher füllen die nicht verwalteten Daten, die dem source Parameter entsprechen, das verwaltete Array unabhängig von seiner Nützlichkeit auf. Sie müssen das verwaltete Array mit der entsprechenden Größe initialisieren, bevor Sie diese Methode aufrufen.

Weitere Informationen

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

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

Quelle:

Marshal.cs

Kopiert Daten aus einem eindimensionalen, verwalteten IntPtr-Array in einen nicht verwalteten Speicherzeiger.

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

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

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

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

Parameter

source

IntPtr[]

nativeint[]

Das eindimensionale Array, aus dem kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Quellarray, an dem der Kopiervorgang beginnen soll.

destination

IntPtr

nativeint

Der Speicherzeiger, in den kopiert werden soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentNullException

source, destination, startIndex oder length ist null.

Hinweise

Sie können diese Methode verwenden, um eine Teilmenge eines eindimensionalen verwalteten IntPtr Arrays in ein nicht verwaltetes Array im C-Stil zu kopieren.

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

Quelle:

Marshal.cs

Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes Array von 8-Bit-Ganzzahlen ohne Vorzeichen.

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

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

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

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

Parameter

source

IntPtr

nativeint

Der Speicherzeiger, aus dem kopiert werden soll.

destination

Byte[]

Das Array, in das kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Zielarray, an dem der Kopiervorgang beginnen soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentNullException

source, destination, startIndex oder length ist null.

Beispiele

Im folgenden Beispiel wird ein Array in den nicht verwalteten Arbeitsspeicher kopiert und dann das nicht verwaltete Array wieder in den verwalteten Arbeitsspeicher kopiert.

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

Hinweise

Nicht verwaltete Arrays im C-Stil enthalten keine Begrenzungsinformationen, wodurch verhindert wird, dass die startIndex Parameter und length überprüft werden. Daher füllen die nicht verwalteten Daten, die dem source Parameter entsprechen, das verwaltete Array unabhängig von seiner Nützlichkeit auf. Sie müssen das verwaltete Array mit der entsprechenden Größe initialisieren, bevor Sie diese Methode aufrufen.

Weitere Informationen

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

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

Quelle:

Marshal.cs

Kopiert Daten aus einem eindimensionalen, verwalteten Array von 64-Bit-Ganzzahlen mit Vorzeichen in einen nicht verwalteten Speicherzeiger.

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

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

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

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

Parameter

source

Int64[]

Das eindimensionale Array, aus dem kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Quellarray, an dem der Kopiervorgang beginnen soll.

destination

IntPtr

nativeint

Der Speicherzeiger, in den kopiert werden soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentOutOfRangeException

startIndex und length sind nicht gültig.

ArgumentNullException

source, startIndex, destination oder length ist null.

Beispiele

Im folgenden Beispiel wird ein Array in den nicht verwalteten Arbeitsspeicher kopiert und dann das nicht verwaltete Array wieder in den verwalteten Arbeitsspeicher kopiert.

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

Hinweise

Sie können diese Methode verwenden, um eine Teilmenge eines eindimensionalen verwalteten Arrays in ein nicht verwaltetes Array im C-Stil zu kopieren.

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

Quelle:

Marshal.cs

Kopiert Daten aus einem eindimensionalen, verwalteten Array von 32-Bit-Ganzzahlen mit Vorzeichen in einen nicht verwalteten Speicherzeiger.

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

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

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

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

Parameter

source

Int32[]

Das eindimensionale Array, aus dem kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Quellarray, an dem der Kopiervorgang beginnen soll.

destination

IntPtr

nativeint

Der Speicherzeiger, in den kopiert werden soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentOutOfRangeException

startIndex und length sind nicht gültig.

ArgumentNullException

startIndex oder length ist null.

Beispiele

Im folgenden Beispiel wird ein Array in den nicht verwalteten Arbeitsspeicher kopiert und dann das nicht verwaltete Array wieder in den verwalteten Arbeitsspeicher kopiert.

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

Hinweise

Sie können diese Methode verwenden, um eine Teilmenge eines eindimensionalen verwalteten Arrays in ein nicht verwaltetes Array im C-Stil zu kopieren.

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

Quelle:

Marshal.cs

Kopiert Daten aus einem eindimensionalen, verwalteten Array von 16-Bit-Ganzzahlen mit Vorzeichen in einen nicht verwalteten Speicherzeiger.

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

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

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

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

Parameter

source

Int16[]

Das eindimensionale Array, aus dem kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Quellarray, an dem der Kopiervorgang beginnen soll.

destination

IntPtr

nativeint

Der Speicherzeiger, in den kopiert werden soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentOutOfRangeException

startIndex und length sind nicht gültig.

ArgumentNullException

source, startIndex, destination oder length ist null.

Beispiele

Im folgenden Beispiel wird ein Array in den nicht verwalteten Arbeitsspeicher kopiert und dann das nicht verwaltete Array wieder in den verwalteten Arbeitsspeicher kopiert.

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

Hinweise

Sie können diese Methode verwenden, um eine Teilmenge eines eindimensionalen verwalteten Arrays in ein nicht verwaltetes Array im C-Stil zu kopieren.

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

Quelle:

Marshal.cs

Kopiert Daten aus einem eindimensionalen, verwalteten Array von Gleitkommazahlen mit doppelter Genauigkeit in einen nicht verwalteten Speicherzeiger.

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

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

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

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

Parameter

source

Double[]

Das eindimensionale Array, aus dem kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Quellarray, an dem der Kopiervorgang beginnen soll.

destination

IntPtr

nativeint

Der Speicherzeiger, in den kopiert werden soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentOutOfRangeException

startIndex und length sind nicht gültig.

ArgumentNullException

source, startIndex, destination oder length ist null.

Beispiele

Im folgenden Beispiel wird ein Array in den nicht verwalteten Arbeitsspeicher kopiert und dann das nicht verwaltete Array wieder in den verwalteten Arbeitsspeicher kopiert.

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

Hinweise

Sie können diese Methode verwenden, um eine Teilmenge eines eindimensionalen verwalteten Arrays in ein nicht verwaltetes Array im C-Stil zu kopieren.

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

Quelle:

Marshal.cs

Kopiert Daten aus einem eindimensionalen, verwalteten Zeichenarray in einen nicht verwalteten Speicherzeiger.

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

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

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

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

Parameter

source

Char[]

Das eindimensionale Array, aus dem kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Quellarray, an dem der Kopiervorgang beginnen soll.

destination

IntPtr

nativeint

Der Speicherzeiger, in den kopiert werden soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentOutOfRangeException

startIndex und length sind nicht gültig.

ArgumentNullException

startIndex, destination oder length ist null.

Beispiele

Im folgenden Beispiel wird ein Array in den nicht verwalteten Arbeitsspeicher kopiert und dann das nicht verwaltete Array wieder in den verwalteten Arbeitsspeicher kopiert.

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

Hinweise

Sie können diese Methode verwenden, um eine Teilmenge eines eindimensionalen verwalteten Arrays in ein nicht verwaltetes Array im C-Stil zu kopieren.

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

Quelle:

Marshal.cs

Kopiert Daten aus einem nicht verwalteten Speicherzeiger in ein verwaltetes Zeichenarray.

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

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

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

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

Parameter

source

IntPtr

nativeint

Der Speicherzeiger, aus dem kopiert werden soll.

destination

Char[]

Das Array, in das kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Zielarray, an dem der Kopiervorgang beginnen soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentNullException

source, destination, startIndex oder length ist null.

Beispiele

Im folgenden Beispiel wird ein Array in den nicht verwalteten Arbeitsspeicher kopiert und dann das nicht verwaltete Array wieder in den verwalteten Arbeitsspeicher kopiert.

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

Hinweise

Nicht verwaltete Arrays im C-Stil enthalten keine Begrenzungsinformationen, wodurch verhindert wird, dass die startIndex Parameter und length überprüft werden. Daher füllen die nicht verwalteten Daten, die dem source Parameter entsprechen, das verwaltete Array unabhängig von seiner Nützlichkeit auf. Sie müssen das verwaltete Array mit der entsprechenden Größe initialisieren, bevor Sie diese Methode aufrufen.

Weitere Informationen

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

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

Quelle:

Marshal.cs

Kopiert Daten aus einem eindimensionalen, verwalteten Array von 8-Bit-Ganzzahlen ohne Vorzeichen in einen nicht verwalteten Speicherzeiger.

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

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

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

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

Parameter

source

Byte[]

Das eindimensionale Array, aus dem kopiert werden soll.

startIndex

Int32

Der nullbasierte Index im Quellarray, an dem der Kopiervorgang beginnen soll.

destination

IntPtr

nativeint

Der Speicherzeiger, in den kopiert werden soll.

length

Int32

Die Anzahl der zu kopierenden Arrayelemente.

Ausnahmen

ArgumentOutOfRangeException

startIndex und length sind nicht gültig.

ArgumentNullException

source, startIndex, destination oder length ist null.

Beispiele

Im folgenden Beispiel wird ein Array mithilfe der Copy(Byte[], Int32, IntPtr, Int32) Überladung in den nicht verwalteten Arbeitsspeicher kopiert und dann das nicht verwaltete Array mithilfe der Überladung in den Copy(IntPtr, Byte[], Int32, Int32) verwalteten Arbeitsspeicher kopiert.

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

Hinweise

Sie können diese Methode verwenden, um eine Teilmenge eines eindimensionalen verwalteten Arrays in ein nicht verwaltetes Array im C-Stil zu kopieren.