Marshal.Copy Metod

Definition

Namnområde:: System.Runtime.InteropServices

Sammansättningar:: mscorlib.dll, System.Runtime.InteropServices.dll

Sammansättningar:: netstandard.dll, System.Runtime.InteropServices.dll

Sammansättning:: System.Runtime.InteropServices.dll

Sammansättning:: mscorlib.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Kopierar data från en hanterad matris till en ohanterad minnespekare eller från en ohanterad minnespekare till en hanterad matris.

Överlagringar

Name	Description
Copy(Single[], Int32, IntPtr, Int32)	Kopierar data från en endimensionell, hanterad flyttal med enkel precision till en ohanterad minnespekare.
Copy(IntPtr, Single[], Int32, Int32)	Kopierar data från en ohanterad minnespekare till en hanterad matris med flyttal med enkel precision.
Copy(IntPtr, IntPtr[], Int32, Int32)	Kopierar data från en ohanterad minnespekare till en hanterad IntPtr matris.
Copy(IntPtr, Int64[], Int32, Int32)	Kopierar data från en ohanterad minnespekare till en hanterad 64-bitars signerad heltalsmatris.
Copy(IntPtr, Int32[], Int32, Int32)	Kopierar data från en ohanterad minnespekare till en hanterad 32-bitars signerad heltalsmatris.
Copy(IntPtr, Int16[], Int32, Int32)	Kopierar data från en ohanterad minnespekare till en hanterad 16-bitars signerad heltalsmatris.
Copy(IntPtr, Double[], Int32, Int32)	Kopierar data från en ohanterad minnespekare till en hanterad flyttal med dubbel precision.
Copy(IntPtr[], Int32, IntPtr, Int32)	Kopierar data från en endimensionell, hanterad IntPtr matris till en ohanterad minnespekare.
Copy(IntPtr, Byte[], Int32, Int32)	Kopierar data från en ohanterad minnespekare till en hanterad 8-bitars osignerad heltalsmatris.
Copy(Int64[], Int32, IntPtr, Int32)	Kopierar data från en endimensionell, hanterad 64-bitars signerad heltalsmatris till en ohanterad minnespekare.
Copy(Int32[], Int32, IntPtr, Int32)	Kopierar data från en endimensionell, hanterad 32-bitars signerad heltalsmatris till en ohanterad minnespekare.
Copy(Int16[], Int32, IntPtr, Int32)	Kopierar data från en endimensionell, hanterad 16-bitars signerad heltalsmatris till en ohanterad minnespekare.
Copy(Double[], Int32, IntPtr, Int32)	Kopierar data från en endimensionell, hanterad flyttal med dubbel precision till en ohanterad minnespekare.
Copy(Char[], Int32, IntPtr, Int32)	Kopierar data från en endimensionell, hanterad teckenmatris till en ohanterad minnespekare.
Copy(IntPtr, Char[], Int32, Int32)	Kopierar data från en ohanterad minnespekare till en hanterad teckenmatris.
Copy(Byte[], Int32, IntPtr, Int32)	Kopierar data från en endimensionell, hanterad 8-bitars osignerad heltalsmatris till en ohanterad minnespekare.

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en endimensionell, hanterad flyttal med enkel precision till en ohanterad minnespekare.

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)

Parametrar

source: Single[]

Den endimensionella matris som ska kopieras från.

startIndex: Int32

Det nollbaserade indexet i källmatrisen där kopieringen ska starta.

destination: IntPtr
nativeint

Minnespekaren som du vill kopiera till.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentOutOfRangeException

startIndex och length är inte giltiga.

ArgumentNullException

source, startIndex, destination, eller length är null.

Kommentarer

Du kan använda den här metoden för att kopiera en delmängd av en endimensionell hanterad matris till en ohanterad C-matris.

Gäller för

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en ohanterad minnespekare till en hanterad matris med flyttal med enkel precision.

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)

Parametrar

source: IntPtr
nativeint

Minnespekaren som du vill kopiera från.

destination: Single[]

Matrisen som ska kopieras till.

startIndex: Int32

Det nollbaserade indexet i målmatrisen där kopieringen ska starta.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentNullException

source, destination, startIndex, eller length är null.

Kommentarer

Ohanterade matriser i C-format innehåller inte bindningsinformation, vilket förhindrar att parametrarna startIndex och length verifieras. Därför fyller de ohanterade data som motsvarar parametern source den hanterade matrisen oavsett dess användbarhet. Du måste initiera den hanterade matrisen med rätt storlek innan du anropar den här metoden.

Se även

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

Gäller för

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en ohanterad minnespekare till en hanterad IntPtr matris.

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)

Parametrar

source: IntPtr
nativeint

Minnespekaren som du vill kopiera från.

destination: IntPtr[]

nativeint[]

Matrisen som ska kopieras till.

startIndex: Int32

Det nollbaserade indexet i målmatrisen där kopieringen ska starta.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentNullException

source, destination, startIndex, eller length är null.

Kommentarer

Gäller för

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en ohanterad minnespekare till en hanterad 64-bitars signerad heltalsmatris.

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)

Parametrar

source: IntPtr
nativeint

Minnespekaren som du vill kopiera från.

destination: Int64[]

Matrisen som ska kopieras till.

startIndex: Int32

Det nollbaserade indexet i målmatrisen där kopieringen ska starta.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentNullException

source, destination, startIndex, eller length är null.

Exempel

I följande exempel kopieras en matris till ohanterat minne och kopierar sedan den ohanterade matrisen tillbaka till hanterat minne.

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

Kommentarer

Ohanterade matriser i C-format innehåller inte bindningsinformation, vilket förhindrar att parametrarna startIndex och length verifieras. Därför fyller de ohanterade data som motsvarar parameternsource den hanterade matrisen oavsett dess användbarhet. Du måste initiera den hanterade matrisen med rätt storlek innan du anropar den här metoden.

Se även

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

Gäller för

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en ohanterad minnespekare till en hanterad 32-bitars signerad heltalsmatris.

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)

Parametrar

source: IntPtr
nativeint

Minnespekaren som du vill kopiera från.

destination: Int32[]

Matrisen som ska kopieras till.

startIndex: Int32

Det nollbaserade indexet i målmatrisen där kopieringen ska starta.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentNullException

source, destination, startIndex, eller length är null.

Exempel

I följande exempel kopieras en matris till ohanterat minne och kopierar sedan den ohanterade matrisen tillbaka till hanterat minne.

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

Kommentarer

Se även

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

Gäller för

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en ohanterad minnespekare till en hanterad 16-bitars signerad heltalsmatris.

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)

Parametrar

source: IntPtr
nativeint

Minnespekaren som du vill kopiera från.

destination: Int16[]

Matrisen som ska kopieras till.

startIndex: Int32

Det nollbaserade indexet i målmatrisen där kopieringen ska starta.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentNullException

source, destination, startIndex, eller length är null.

Exempel

I följande exempel kopieras en matris till ohanterat minne och kopierar sedan den ohanterade matrisen tillbaka till hanterat minne.

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

Kommentarer

Se även

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

Gäller för

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en ohanterad minnespekare till en hanterad flyttal med dubbel precision.

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)

Parametrar

source: IntPtr
nativeint

Minnespekaren som du vill kopiera från.

destination: Double[]

Matrisen som ska kopieras till.

startIndex: Int32

Det nollbaserade indexet i målmatrisen där kopieringen ska starta.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentNullException

source, destination, startIndex, eller length är null.

Exempel

I följande exempel kopieras en matris till ohanterat minne och kopierar sedan den ohanterade matrisen tillbaka till hanterat minne.

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

Kommentarer

Se även

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

Gäller för

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en endimensionell, hanterad IntPtr matris till en ohanterad minnespekare.

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)

Parametrar

source: IntPtr[]

nativeint[]

Den endimensionella matris som ska kopieras från.

startIndex: Int32

Det nollbaserade indexet i källmatrisen där kopieringen ska starta.

destination: IntPtr
nativeint

Minnespekaren som du vill kopiera till.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentNullException

source, destination, startIndex, eller length är null.

Kommentarer

Du kan använda den här metoden för att kopiera en delmängd av en endimensionell hanterad IntPtr matris till en ohanterad C-matris.

Gäller för

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en ohanterad minnespekare till en hanterad 8-bitars osignerad heltalsmatris.

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)

Parametrar

source: IntPtr
nativeint

Minnespekaren som du vill kopiera från.

destination: Byte[]

Matrisen som ska kopieras till.

startIndex: Int32

Det nollbaserade indexet i målmatrisen där kopieringen ska starta.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentNullException

source, destination, startIndex, eller length är null.

Exempel

I följande exempel kopieras en matris till ohanterat minne och kopierar sedan den ohanterade matrisen tillbaka till hanterat minne.

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

Kommentarer

Se även

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

Gäller för

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en endimensionell, hanterad 64-bitars signerad heltalsmatris till en ohanterad minnespekare.

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)

Parametrar

source: Int64[]

Den endimensionella matris som ska kopieras från.

startIndex: Int32

Det nollbaserade indexet i källmatrisen där kopieringen ska starta.

destination: IntPtr
nativeint

Minnespekaren som du vill kopiera till.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentOutOfRangeException

startIndex och length är inte giltiga.

ArgumentNullException

source, startIndex, destination, eller length är null.

Exempel

I följande exempel kopieras en matris till ohanterat minne och kopierar sedan den ohanterade matrisen tillbaka till hanterat minne.

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

Kommentarer

Du kan använda den här metoden för att kopiera en delmängd av en endimensionell hanterad matris till en ohanterad C-matris.

Gäller för

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en endimensionell, hanterad 32-bitars signerad heltalsmatris till en ohanterad minnespekare.

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)

Parametrar

source: Int32[]

Den endimensionella matris som ska kopieras från.

startIndex: Int32

Det nollbaserade indexet i källmatrisen där kopieringen ska starta.

destination: IntPtr
nativeint

Minnespekaren som du vill kopiera till.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentOutOfRangeException

startIndex och length är inte giltiga.

ArgumentNullException

startIndex eller length är null.

Exempel

I följande exempel kopieras en matris till ohanterat minne och kopierar sedan den ohanterade matrisen tillbaka till hanterat minne.

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

Kommentarer

Du kan använda den här metoden för att kopiera en delmängd av en endimensionell hanterad matris till en ohanterad C-matris.

Gäller för

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en endimensionell, hanterad 16-bitars signerad heltalsmatris till en ohanterad minnespekare.

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)

Parametrar

source: Int16[]

Den endimensionella matris som ska kopieras från.

startIndex: Int32

Det nollbaserade indexet i källmatrisen där kopieringen ska starta.

destination: IntPtr
nativeint

Minnespekaren som du vill kopiera till.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentOutOfRangeException

startIndex och length är inte giltiga.

ArgumentNullException

source, startIndex, destination, eller length är null.

Exempel

I följande exempel kopieras en matris till ohanterat minne och kopierar sedan den ohanterade matrisen tillbaka till hanterat minne.

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

Kommentarer

Du kan använda den här metoden för att kopiera en delmängd av en endimensionell hanterad matris till en ohanterad C-matris.

Gäller för

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en endimensionell, hanterad flyttal med dubbel precision till en ohanterad minnespekare.

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)

Parametrar

source: Double[]

Den endimensionella matris som ska kopieras från.

startIndex: Int32

Det nollbaserade indexet i källmatrisen där kopieringen ska starta.

destination: IntPtr
nativeint

Minnespekaren som du vill kopiera till.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentOutOfRangeException

startIndex och length är inte giltiga.

ArgumentNullException

source, startIndex, destination, eller length är null.

Exempel

I följande exempel kopieras en matris till ohanterat minne och kopierar sedan den ohanterade matrisen tillbaka till hanterat minne.

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

Kommentarer

Du kan använda den här metoden för att kopiera en delmängd av en endimensionell hanterad matris till en ohanterad C-matris.

Gäller för

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en endimensionell, hanterad teckenmatris till en ohanterad minnespekare.

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)

Parametrar

source: Char[]

Den endimensionella matris som ska kopieras från.

startIndex: Int32

Det nollbaserade indexet i källmatrisen där kopieringen ska starta.

destination: IntPtr
nativeint

Minnespekaren som du vill kopiera till.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentOutOfRangeException

startIndex och length är inte giltiga.

ArgumentNullException

startIndex, destination, eller length är null.

Exempel

I följande exempel kopieras en matris till ohanterat minne och kopierar sedan den ohanterade matrisen tillbaka till hanterat minne.

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

Kommentarer

Du kan använda den här metoden för att kopiera en delmängd av en endimensionell hanterad matris till en ohanterad C-matris.

Gäller för

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en ohanterad minnespekare till en hanterad teckenmatris.

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)

Parametrar

source: IntPtr
nativeint

Minnespekaren som du vill kopiera från.

destination: Char[]

Matrisen som ska kopieras till.

startIndex: Int32

Det nollbaserade indexet i målmatrisen där kopieringen ska starta.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentNullException

source, destination, startIndex, eller length är null.

Exempel

I följande exempel kopieras en matris till ohanterat minne och kopierar sedan den ohanterade matrisen tillbaka till hanterat minne.

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

Kommentarer

Se även

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

Gäller för

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

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Källa:: Marshal.cs

Kopierar data från en endimensionell, hanterad 8-bitars osignerad heltalsmatris till en ohanterad minnespekare.

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)

Parametrar

source: Byte[]

Den endimensionella matris som ska kopieras från.

startIndex: Int32

Det nollbaserade indexet i källmatrisen där kopieringen ska starta.

destination: IntPtr
nativeint

Minnespekaren som du vill kopiera till.

length: Int32

Antalet matriselement som ska kopieras.

Attribut: SecurityCriticalAttribute

Undantag

ArgumentOutOfRangeException

startIndex och length är inte giltiga.

ArgumentNullException

source, startIndex, destination, eller length är null.

Exempel

I följande exempel kopieras en matris till ohanterat minne med hjälp av överlagringen Copy(Byte[], Int32, IntPtr, Int32) och kopierar sedan den ohanterade matrisen tillbaka till hanterat minne med hjälp av överlagringen Copy(IntPtr, Byte[], Int32, Int32) .

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

Kommentarer

Du kan använda den här metoden för att kopiera en delmängd av en endimensionell hanterad matris till en ohanterad C-matris.

Gäller för

Feedback

Var den här sidan till hjälp?