Marshal.Copy Methode

Definitie

Naamruimte:
System.Runtime.InteropServices
Assembly's:
mscorlib.dll, System.Runtime.InteropServices.dll
Assembly's:
netstandard.dll, System.Runtime.InteropServices.dll
Assembly:
System.Runtime.InteropServices.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Hiermee kopieert u gegevens van een beheerde matrix naar een niet-beheerde geheugenaanwijzer of van een niet-beheerde geheugenaanwijzer naar een beheerde matrix.

Overloads

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

Hiermee kopieert u gegevens van een eendimensionale, beheerde drijvendekommanummermatrix met één precisie naar een onbeheerde geheugenaanwijzer.
Copy(IntPtr, Single[], Int32, Int32)

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde drijvendekommatrix met één precisie.
Copy(IntPtr, IntPtr[], Int32, Int32)

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde IntPtr matrix.
Copy(IntPtr, Int64[], Int32, Int32)

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde 64-bits matrix met ondertekende gehele getallen.
Copy(IntPtr, Int32[], Int32, Int32)

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde 32-bits matrix met ondertekende gehele getallen.
Copy(IntPtr, Int16[], Int32, Int32)

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde 16-bits matrix met ondertekende gehele getallen.
Copy(IntPtr, Double[], Int32, Int32)

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde matrix met drijvendekommanummers met dubbele precisie.
Copy(IntPtr[], Int32, IntPtr, Int32)

Hiermee kopieert u gegevens van een eendimensionale, beheerde IntPtr matrix naar een niet-beheerde geheugenaanwijzer.
Copy(IntPtr, Byte[], Int32, Int32)

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde 8-bits niet-ondertekende gehele getallenmatrix.
Copy(Int64[], Int32, IntPtr, Int32)

Hiermee kopieert u gegevens van een eendimensionale, beheerde 64-bits matrix met ondertekende gehele getallen naar een onbeheerde geheugenaanwijzer.
Copy(Int32[], Int32, IntPtr, Int32)

Hiermee kopieert u gegevens van een eendimensionale, beheerde 32-bits matrix met ondertekende gehele getallen naar een niet-beheerde geheugenaanwijzer.
Copy(Int16[], Int32, IntPtr, Int32)

Hiermee kopieert u gegevens van een eendimensionale, beheerde 16-bits matrix met ondertekende gehele getallen naar een niet-beheerde geheugenaanwijzer.
Copy(Double[], Int32, IntPtr, Int32)

Hiermee kopieert u gegevens van een eendimensionale, beheerde drijvendekommanummermatrix met dubbele precisie naar een onbeheerde geheugenaanwijzer.
Copy(Char[], Int32, IntPtr, Int32)

Hiermee kopieert u gegevens van een eendimensionale, beheerde tekenmatrix naar een onbeheerde geheugenaanwijzer.
Copy(IntPtr, Char[], Int32, Int32)

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde tekenmatrix.
Copy(Byte[], Int32, IntPtr, Int32)

Hiermee kopieert u gegevens van een eendimensionale, beheerde 8-bits niet-ondertekende gehele getallenmatrix naar een niet-beheerde geheugenaanwijzer.

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een eendimensionale, beheerde drijvendekommanummermatrix met één precisie naar een onbeheerde geheugenaanwijzer.

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)

Parameters

source
Single[]

De eendimensionale matrix waaruit moet worden gekopieerd.

startIndex
Int32

De op nul gebaseerde index in de bronmatrix waar kopiëren moet worden gestart.

destination
IntPtr

nativeint

De aanwijzer naar het geheugen om naar te kopiëren.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentOutOfRangeException

startIndex en length zijn niet geldig.

ArgumentNullException

source, startIndex, destinationof length is null.

Opmerkingen

U kunt deze methode gebruiken om een subset van een eendimensionale beheerde matrix te kopiëren naar een niet-beheerde C-stijlmatrix.

Van toepassing op

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde drijvendekommatrix met één precisie.

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)

Parameters

source
IntPtr

nativeint

De geheugenpointer waaruit moet worden gekopieerd.

destination
Single[]

De matrix naar kopiëren.

startIndex
Int32

De op nul gebaseerde index in de doelmatrix waar kopiëren moet worden gestart.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentNullException

source, destination, startIndexof length is null.

Opmerkingen

Onbeheerde, C-achtige matrices bevatten geen gegevens over grenzen, waardoor de startIndex parameters niet length kunnen worden gevalideerd. De niet-beheerde gegevens die overeenkomen met de source parameter vullen de beheerde matrix dus, ongeacht de bruikbaarheid ervan. U moet de beheerde matrix initialiseren met de juiste grootte voordat u deze methode aanroept.

Zie ook

Van toepassing op

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde IntPtr matrix.

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)

Parameters

source
IntPtr

nativeint

De geheugenpointer waaruit moet worden gekopieerd.

destination

IntPtr[]

nativeint[]

De matrix naar kopiëren.

startIndex
Int32

De op nul gebaseerde index in de doelmatrix waar kopiëren moet worden gestart.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentNullException

source, destination, startIndexof length is null.

Opmerkingen

Onbeheerde, C-achtige matrices bevatten geen gegevens over grenzen, waardoor de startIndex parameters niet length kunnen worden gevalideerd. Daarom worden de niet-beheerde gegevens die overeenkomen met de source parameter de beheerde matrix gevuld, ongeacht de bruikbaarheid ervan. U moet de beheerde matrix initialiseren met de juiste grootte voordat u de Marshal.Copy methode aanroept.

Van toepassing op

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde 64-bits matrix met ondertekende gehele getallen.

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)

Parameters

source
IntPtr

nativeint

De geheugenpointer waaruit moet worden gekopieerd.

destination
Int64[]

De matrix naar kopiëren.

startIndex
Int32

De op nul gebaseerde index in de doelmatrix waar kopiëren moet worden gestart.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentNullException

source, destination, startIndexof length is null.

Voorbeelden

In het volgende voorbeeld wordt een matrix gekopieerd naar onbeheerd geheugen en wordt vervolgens de niet-beheerde matrix terug gekopieerd naar het beheerde geheugen.

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

Opmerkingen

Onbeheerde, C-achtige matrices bevatten geen gegevens over grenzen, waardoor de startIndex parameters niet length kunnen worden gevalideerd. De niet-beheerde gegevens die overeenkomen met desource parameter vullen de beheerde matrix dus, ongeacht de bruikbaarheid ervan. U moet de beheerde matrix initialiseren met de juiste grootte voordat u deze methode aanroept.

Zie ook

Van toepassing op

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde 32-bits matrix met ondertekende gehele getallen.

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)

Parameters

source
IntPtr

nativeint

De geheugenpointer waaruit moet worden gekopieerd.

destination
Int32[]

De matrix naar kopiëren.

startIndex
Int32

De op nul gebaseerde index in de doelmatrix waar kopiëren moet worden gestart.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentNullException

source, destination, startIndexof length is null.

Voorbeelden

In het volgende voorbeeld wordt een matrix gekopieerd naar onbeheerd geheugen en wordt vervolgens de niet-beheerde matrix terug gekopieerd naar het beheerde geheugen.

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

Opmerkingen

Onbeheerde, C-achtige matrices bevatten geen gegevens over grenzen, waardoor de startIndex parameters niet length kunnen worden gevalideerd. De niet-beheerde gegevens die overeenkomen met de source parameter vullen de beheerde matrix dus, ongeacht de bruikbaarheid ervan. U moet de beheerde matrix initialiseren met de juiste grootte voordat u deze methode aanroept.

Zie ook

Van toepassing op

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde 16-bits matrix met ondertekende gehele getallen.

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)

Parameters

source
IntPtr

nativeint

De geheugenpointer waaruit moet worden gekopieerd.

destination
Int16[]

De matrix naar kopiëren.

startIndex
Int32

De op nul gebaseerde index in de doelmatrix waar kopiëren moet worden gestart.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentNullException

source, destination, startIndexof length is null.

Voorbeelden

In het volgende voorbeeld wordt een matrix gekopieerd naar onbeheerd geheugen en wordt vervolgens de niet-beheerde matrix terug gekopieerd naar het beheerde geheugen.

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

Opmerkingen

Onbeheerde, C-achtige matrices bevatten geen gegevens over grenzen, waardoor de startIndex parameters niet length kunnen worden gevalideerd. De niet-beheerde gegevens die overeenkomen met de source parameter vullen de beheerde matrix dus, ongeacht de bruikbaarheid ervan. U moet de beheerde matrix initialiseren met de juiste grootte voordat u deze methode aanroept.

Zie ook

Van toepassing op

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde matrix met drijvendekommanummers met dubbele precisie.

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)

Parameters

source
IntPtr

nativeint

De geheugenpointer waaruit moet worden gekopieerd.

destination
Double[]

De matrix naar kopiëren.

startIndex
Int32

De op nul gebaseerde index in de doelmatrix waar kopiëren moet worden gestart.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentNullException

source, destination, startIndexof length is null.

Voorbeelden

In het volgende voorbeeld wordt een matrix gekopieerd naar onbeheerd geheugen en wordt vervolgens de niet-beheerde matrix terug gekopieerd naar het beheerde geheugen.

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

Opmerkingen

Onbeheerde, C-achtige matrices bevatten geen gegevens over grenzen, waardoor de startIndex parameters niet length kunnen worden gevalideerd. De niet-beheerde gegevens die overeenkomen met de source parameter vullen de beheerde matrix dus, ongeacht de bruikbaarheid ervan. U moet de beheerde matrix initialiseren met de juiste grootte voordat u deze methode aanroept.

Zie ook

Van toepassing op

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een eendimensionale, beheerde IntPtr matrix naar een niet-beheerde geheugenaanwijzer.

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)

Parameters

source

IntPtr[]

nativeint[]

De eendimensionale matrix waaruit moet worden gekopieerd.

startIndex
Int32

De op nul gebaseerde index in de bronmatrix waar kopiëren moet worden gestart.

destination
IntPtr

nativeint

De aanwijzer naar het geheugen om naar te kopiëren.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentNullException

source, destination, startIndexof length is null.

Opmerkingen

U kunt deze methode gebruiken om een subset van een eendimensionale beheerde IntPtr matrix te kopiëren naar een niet-beheerde C-stijlmatrix.

Van toepassing op

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde 8-bits niet-ondertekende gehele getallenmatrix.

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)

Parameters

source
IntPtr

nativeint

De geheugenpointer waaruit moet worden gekopieerd.

destination
Byte[]

De matrix naar kopiëren.

startIndex
Int32

De op nul gebaseerde index in de doelmatrix waar kopiëren moet worden gestart.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentNullException

source, destination, startIndexof length is null.

Voorbeelden

In het volgende voorbeeld wordt een matrix gekopieerd naar onbeheerd geheugen en wordt vervolgens de niet-beheerde matrix terug gekopieerd naar het beheerde geheugen.

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

Opmerkingen

Onbeheerde, C-achtige matrices bevatten geen gegevens over grenzen, waardoor de startIndex parameters niet length kunnen worden gevalideerd. De niet-beheerde gegevens die overeenkomen met de source parameter vullen de beheerde matrix dus, ongeacht de bruikbaarheid ervan. U moet de beheerde matrix initialiseren met de juiste grootte voordat u deze methode aanroept.

Zie ook

Van toepassing op

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een eendimensionale, beheerde 64-bits matrix met ondertekende gehele getallen naar een onbeheerde geheugenaanwijzer.

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)

Parameters

source
Int64[]

De eendimensionale matrix waaruit moet worden gekopieerd.

startIndex
Int32

De op nul gebaseerde index in de bronmatrix waar kopiëren moet worden gestart.

destination
IntPtr

nativeint

De aanwijzer naar het geheugen om naar te kopiëren.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentOutOfRangeException

startIndex en length zijn niet geldig.

ArgumentNullException

source, startIndex, destinationof length is null.

Voorbeelden

In het volgende voorbeeld wordt een matrix gekopieerd naar onbeheerd geheugen en wordt vervolgens de niet-beheerde matrix terug gekopieerd naar het beheerde geheugen.

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

Opmerkingen

U kunt deze methode gebruiken om een subset van een eendimensionale beheerde matrix te kopiëren naar een niet-beheerde C-stijlmatrix.

Van toepassing op

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een eendimensionale, beheerde 32-bits matrix met ondertekende gehele getallen naar een niet-beheerde geheugenaanwijzer.

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)

Parameters

source
Int32[]

De eendimensionale matrix waaruit moet worden gekopieerd.

startIndex
Int32

De op nul gebaseerde index in de bronmatrix waar kopiëren moet worden gestart.

destination
IntPtr

nativeint

De aanwijzer naar het geheugen om naar te kopiëren.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentOutOfRangeException

startIndex en length zijn niet geldig.

ArgumentNullException

startIndex of length is null.

Voorbeelden

In het volgende voorbeeld wordt een matrix gekopieerd naar onbeheerd geheugen en wordt vervolgens de niet-beheerde matrix terug gekopieerd naar het beheerde geheugen.

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

Opmerkingen

U kunt deze methode gebruiken om een subset van een eendimensionale beheerde matrix te kopiëren naar een niet-beheerde C-stijlmatrix.

Van toepassing op

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een eendimensionale, beheerde 16-bits matrix met ondertekende gehele getallen naar een niet-beheerde geheugenaanwijzer.

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)

Parameters

source
Int16[]

De eendimensionale matrix waaruit moet worden gekopieerd.

startIndex
Int32

De op nul gebaseerde index in de bronmatrix waar kopiëren moet worden gestart.

destination
IntPtr

nativeint

De aanwijzer naar het geheugen om naar te kopiëren.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentOutOfRangeException

startIndex en length zijn niet geldig.

ArgumentNullException

source, startIndex, destinationof length is null.

Voorbeelden

In het volgende voorbeeld wordt een matrix gekopieerd naar onbeheerd geheugen en wordt vervolgens de niet-beheerde matrix terug gekopieerd naar het beheerde geheugen.

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

Opmerkingen

U kunt deze methode gebruiken om een subset van een eendimensionale beheerde matrix te kopiëren naar een niet-beheerde C-stijlmatrix.

Van toepassing op

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een eendimensionale, beheerde drijvendekommanummermatrix met dubbele precisie naar een onbeheerde geheugenaanwijzer.

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)

Parameters

source
Double[]

De eendimensionale matrix waaruit moet worden gekopieerd.

startIndex
Int32

De op nul gebaseerde index in de bronmatrix waar kopiëren moet worden gestart.

destination
IntPtr

nativeint

De aanwijzer naar het geheugen om naar te kopiëren.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentOutOfRangeException

startIndex en length zijn niet geldig.

ArgumentNullException

source, startIndex, destinationof length is null.

Voorbeelden

In het volgende voorbeeld wordt een matrix gekopieerd naar onbeheerd geheugen en wordt vervolgens de niet-beheerde matrix terug gekopieerd naar het beheerde geheugen.

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

Opmerkingen

U kunt deze methode gebruiken om een subset van een eendimensionale beheerde matrix te kopiëren naar een niet-beheerde C-stijlmatrix.

Van toepassing op

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een eendimensionale, beheerde tekenmatrix naar een onbeheerde geheugenaanwijzer.

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)

Parameters

source
Char[]

De eendimensionale matrix waaruit moet worden gekopieerd.

startIndex
Int32

De op nul gebaseerde index in de bronmatrix waar kopiëren moet worden gestart.

destination
IntPtr

nativeint

De aanwijzer naar het geheugen om naar te kopiëren.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentOutOfRangeException

startIndex en length zijn niet geldig.

ArgumentNullException

startIndex, destinationof length is null.

Voorbeelden

In het volgende voorbeeld wordt een matrix gekopieerd naar onbeheerd geheugen en wordt vervolgens de niet-beheerde matrix terug gekopieerd naar het beheerde geheugen.

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

Opmerkingen

U kunt deze methode gebruiken om een subset van een eendimensionale beheerde matrix te kopiëren naar een niet-beheerde C-stijlmatrix.

Van toepassing op

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een niet-beheerde geheugenaanwijzer naar een beheerde tekenmatrix.

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)

Parameters

source
IntPtr

nativeint

De geheugenpointer waaruit moet worden gekopieerd.

destination
Char[]

De matrix naar kopiëren.

startIndex
Int32

De op nul gebaseerde index in de doelmatrix waar kopiëren moet worden gestart.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentNullException

source, destination, startIndexof length is null.

Voorbeelden

In het volgende voorbeeld wordt een matrix gekopieerd naar onbeheerd geheugen en wordt vervolgens de niet-beheerde matrix terug gekopieerd naar het beheerde geheugen.

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

Opmerkingen

Onbeheerde, C-achtige matrices bevatten geen gegevens over grenzen, waardoor de startIndex parameters niet length kunnen worden gevalideerd. De niet-beheerde gegevens die overeenkomen met de source parameter vullen de beheerde matrix dus, ongeacht de bruikbaarheid ervan. U moet de beheerde matrix initialiseren met de juiste grootte voordat u deze methode aanroept.

Zie ook

Van toepassing op

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

Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs
Bron:
Marshal.cs

Hiermee kopieert u gegevens van een eendimensionale, beheerde 8-bits niet-ondertekende gehele getallenmatrix naar een niet-beheerde geheugenaanwijzer.

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)

Parameters

source
Byte[]

De eendimensionale matrix waaruit moet worden gekopieerd.

startIndex
Int32

De op nul gebaseerde index in de bronmatrix waar kopiëren moet worden gestart.

destination
IntPtr

nativeint

De aanwijzer naar het geheugen om naar te kopiëren.

length
Int32

Het aantal matrixelementen dat moet worden gekopieerd.

Kenmerken
SecurityCriticalAttribute

Uitzonderingen

ArgumentOutOfRangeException

startIndex en length zijn niet geldig.

ArgumentNullException

source, startIndex, destinationof length is null.

Voorbeelden

In het volgende voorbeeld wordt een matrix gekopieerd naar onbeheerd geheugen met behulp van de Copy(Byte[], Int32, IntPtr, Int32) overbelasting en kopieert de onbeheerde matrix vervolgens terug naar het beheerde geheugen met behulp van de Copy(IntPtr, Byte[], Int32, Int32) overbelasting.

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

Opmerkingen

U kunt deze methode gebruiken om een subset van een eendimensionale beheerde matrix te kopiëren naar een niet-beheerde C-stijlmatrix.

Van toepassing op