Marshal.Copy Yöntem

Başvuru

Tanım

Ad Alanı:: System.Runtime.InteropServices

Bütünleştirilmiş Kod:: System.Runtime.InteropServices.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Bütünleştirilmiş Kod:: netstandard.dll

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

Yönetilen diziden yönetilmeyen bir bellek işaretçisine veya yönetilmeyen bir bellek işaretçisinden yönetilen bir diziye veri kopyalar.

Aşırı Yüklemeler

Copy(Single[], Int32, IntPtr, Int32)	Tek boyutlu, yönetilen tek duyarlıklı kayan noktalı sayı dizisinden yönetilmeyen bir bellek işaretçisine veri kopyalar.
Copy(IntPtr, Single[], Int32, Int32)	Yönetilmeyen bir bellek işaretçisinden yönetilen tek duyarlıklı kayan noktalı sayı dizisine veri kopyalar.
Copy(IntPtr, IntPtr[], Int32, Int32)	Yönetilmeyen bir bellek işaretçisinden yönetilen IntPtr bir diziye veri kopyalar.
Copy(IntPtr, Int64[], Int32, Int32)	Yönetilmeyen bir bellek işaretçisinden yönetilen 64 bit imzalı tamsayı dizisine veri kopyalar.
Copy(IntPtr, Int32[], Int32, Int32)	Yönetilmeyen bir bellek işaretçisinden yönetilen 32 bit imzalı tamsayı dizisine veri kopyalar.
Copy(IntPtr, Int16[], Int32, Int32)	Yönetilmeyen bir bellek işaretçisinden yönetilen 16 bit imzalı tamsayı dizisine veri kopyalar.
Copy(IntPtr, Double[], Int32, Int32)	Yönetilmeyen bir bellek işaretçisinden yönetilen çift duyarlıklı kayan noktalı sayı dizisine veri kopyalar.
Copy(IntPtr[], Int32, IntPtr, Int32)	Tek boyutlu, yönetilen IntPtr bir diziden yönetilmeyen bir bellek işaretçisine veri kopyalar.
Copy(IntPtr, Byte[], Int32, Int32)	Yönetilmeyen bir bellek işaretçisinden yönetilen 8 bit imzasız tamsayı dizisine veri kopyalar.
Copy(Int64[], Int32, IntPtr, Int32)	Tek boyutlu, yönetilen 64 bit imzalı bir tamsayı dizisinden yönetilmeyen bir bellek işaretçisine veri kopyalar.
Copy(Int32[], Int32, IntPtr, Int32)	Verileri tek boyutlu, yönetilen 32 bit imzalı bir tamsayı dizisinden yönetilmeyen bir bellek işaretçisine kopyalar.
Copy(Int16[], Int32, IntPtr, Int32)	Tek boyutlu, yönetilen 16 bit imzalı bir tamsayı dizisinden yönetilmeyen bir bellek işaretçisine veri kopyalar.
Copy(Double[], Int32, IntPtr, Int32)	Tek boyutlu, yönetilen çift duyarlıklı kayan noktalı sayı dizisinden yönetilmeyen bir bellek işaretçisine veri kopyalar.
Copy(Char[], Int32, IntPtr, Int32)	Tek boyutlu, yönetilen karakter dizisinden yönetilmeyen bir bellek işaretçisine veri kopyalar.
Copy(IntPtr, Char[], Int32, Int32)	Yönetilmeyen bir bellek işaretçisinden yönetilen karakter dizisine veri kopyalar.
Copy(Byte[], Int32, IntPtr, Int32)	Tek boyutlu, yönetilen 8 bit imzasız tamsayı dizisinden yönetilmeyen bir bellek işaretçisine veri kopyalar.

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Tek boyutlu, yönetilen tek duyarlıklı kayan noktalı sayı dizisinden yönetilmeyen bir bellek işaretçisine veri kopyalar.

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)

Parametreler

source: Single[]

Kopyalanacak tek boyutlu dizi.

startIndex: Int32

Kaynak dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

destination: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentOutOfRangeException

startIndex ve length geçerli değildir.

ArgumentNullException

source, startIndex, destinationveya length şeklindedir null.

Açıklamalar

Tek boyutlu yönetilen bir dizinin alt kümesini yönetilmeyen C stili bir diziye kopyalamak için bu yöntemi kullanabilirsiniz.

Şunlara uygulanır

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Yönetilmeyen bir bellek işaretçisinden yönetilen tek duyarlıklı kayan noktalı sayı dizisine veri kopyalar.

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)

Parametreler

source: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

destination: Single[]

Kopyalanacak dizi.

startIndex: Int32

Hedef dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentNullException

source, destination, startIndexveya length şeklindedir null.

Açıklamalar

Yönetilmeyen C stili diziler, ve length parametrelerinin startIndex doğrulanmasını engelleyen sınır bilgileri içermez. Bu nedenle, parametresine source karşılık gelen yönetilmeyen veriler, kullanışlılığına bakılmaksızın yönetilen diziyi doldurur. Bu yöntemi çağırmadan önce yönetilen diziyi uygun boyutla başlatmanız gerekir.

Ayrıca bkz.

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

Şunlara uygulanır

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Yönetilmeyen bir bellek işaretçisinden yönetilen IntPtr bir diziye veri kopyalar.

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)

Parametreler

source: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

destination: IntPtr[]

nativeint[]

Kopyalanacak dizi.

startIndex: Int32

Hedef dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentNullException

source, destination, startIndexveya length şeklindedir null.

Açıklamalar

Yönetilmeyen C stili diziler, ve length parametrelerinin startIndex doğrulanmasını engelleyen sınır bilgileri içermez. Bu nedenle, parametresine source karşılık gelen yönetilmeyen veriler, kullanışlılığına bakılmaksızın yönetilen diziyi doldurur. yöntemini çağırmadan Marshal.Copy önce yönetilen diziyi uygun boyutla başlatmanız gerekir.

Şunlara uygulanır

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Yönetilmeyen bir bellek işaretçisinden yönetilen 64 bit imzalı tamsayı dizisine veri kopyalar.

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)

Parametreler

source: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

destination: Int64[]

Kopyalanacak dizi.

startIndex: Int32

Hedef dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentNullException

source, destination, startIndexveya length şeklindedir null.

Örnekler

Aşağıdaki örnek bir diziyi yönetilmeyen belleğe kopyalar ve ardından yönetilmeyen diziyi yönetilen belleğe geri kopyalar.

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

Açıklamalar

Yönetilmeyen C stili diziler, ve length parametrelerinin startIndex doğrulanmasını engelleyen sınır bilgileri içermez. Bu nedenle, parametresinesource karşılık gelen yönetilmeyen veriler, kullanışlılığına bakılmaksızın yönetilen diziyi doldurur. Bu yöntemi çağırmadan önce yönetilen diziyi uygun boyutla başlatmanız gerekir.

Ayrıca bkz.

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

Şunlara uygulanır

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Yönetilmeyen bir bellek işaretçisinden yönetilen 32 bit imzalı tamsayı dizisine veri kopyalar.

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)

Parametreler

source: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

destination: Int32[]

Kopyalanacak dizi.

startIndex: Int32

Hedef dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentNullException

source, destination, startIndexveya length şeklindedir null.

Örnekler

Aşağıdaki örnek bir diziyi yönetilmeyen belleğe kopyalar ve ardından yönetilmeyen diziyi yönetilen belleğe geri kopyalar.

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

Açıklamalar

Ayrıca bkz.

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

Şunlara uygulanır

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Yönetilmeyen bir bellek işaretçisinden yönetilen 16 bit imzalı tamsayı dizisine veri kopyalar.

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)

Parametreler

source: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

destination: Int16[]

Kopyalanacak dizi.

startIndex: Int32

Hedef dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentNullException

source, destination, startIndexveya length şeklindedir null.

Örnekler

Aşağıdaki örnek bir diziyi yönetilmeyen belleğe kopyalar ve ardından yönetilmeyen diziyi yönetilen belleğe geri kopyalar.

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

Açıklamalar

Ayrıca bkz.

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

Şunlara uygulanır

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Yönetilmeyen bir bellek işaretçisinden yönetilen çift duyarlıklı kayan noktalı sayı dizisine veri kopyalar.

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)

Parametreler

source: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

destination: Double[]

Kopyalanacak dizi.

startIndex: Int32

Hedef dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentNullException

source, destination, startIndexveya length şeklindedir null.

Örnekler

Aşağıdaki örnek bir diziyi yönetilmeyen belleğe kopyalar ve ardından yönetilmeyen diziyi yönetilen belleğe geri kopyalar.

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

Açıklamalar

Ayrıca bkz.

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

Şunlara uygulanır

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Tek boyutlu, yönetilen IntPtr bir diziden yönetilmeyen bir bellek işaretçisine veri kopyalar.

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)

Parametreler

source: IntPtr[]

nativeint[]

Kopyalanacak tek boyutlu dizi.

startIndex: Int32

Kaynak dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

destination: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentNullException

source, destination, startIndexveya length şeklindedir null.

Açıklamalar

Tek boyutlu yönetilen IntPtr bir dizinin alt kümesini yönetilmeyen C stili bir diziye kopyalamak için bu yöntemi kullanabilirsiniz.

Şunlara uygulanır

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Yönetilmeyen bir bellek işaretçisinden yönetilen 8 bit imzasız tamsayı dizisine veri kopyalar.

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)

Parametreler

source: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

destination: Byte[]

Kopyalanacak dizi.

startIndex: Int32

Hedef dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentNullException

source, destination, startIndexveya length şeklindedir null.

Örnekler

Aşağıdaki örnek bir diziyi yönetilmeyen belleğe kopyalar ve ardından yönetilmeyen diziyi yönetilen belleğe geri kopyalar.

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

Açıklamalar

Ayrıca bkz.

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

Şunlara uygulanır

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Tek boyutlu, yönetilen 64 bit imzalı bir tamsayı dizisinden yönetilmeyen bir bellek işaretçisine veri kopyalar.

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)

Parametreler

source: Int64[]

Kopyalanacak tek boyutlu dizi.

startIndex: Int32

Kaynak dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

destination: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentOutOfRangeException

startIndex ve length geçerli değildir.

ArgumentNullException

source, startIndex, destinationveya length şeklindedir null.

Örnekler

Aşağıdaki örnek bir diziyi yönetilmeyen belleğe kopyalar ve ardından yönetilmeyen diziyi yönetilen belleğe geri kopyalar.

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

Açıklamalar

Tek boyutlu yönetilen bir dizinin alt kümesini yönetilmeyen C stili bir diziye kopyalamak için bu yöntemi kullanabilirsiniz.

Şunlara uygulanır

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Verileri tek boyutlu, yönetilen 32 bit imzalı bir tamsayı dizisinden yönetilmeyen bir bellek işaretçisine kopyalar.

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)

Parametreler

source: Int32[]

Kopyalanacak tek boyutlu dizi.

startIndex: Int32

Kaynak dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

destination: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentOutOfRangeException

startIndex ve length geçerli değildir.

ArgumentNullException

startIndex veya length şeklindedir null.

Örnekler

Aşağıdaki örnek bir diziyi yönetilmeyen belleğe kopyalar ve ardından yönetilmeyen diziyi yönetilen belleğe geri kopyalar.

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

Açıklamalar

Tek boyutlu yönetilen bir dizinin alt kümesini yönetilmeyen C stili bir diziye kopyalamak için bu yöntemi kullanabilirsiniz.

Şunlara uygulanır

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Tek boyutlu, yönetilen 16 bit imzalı bir tamsayı dizisinden yönetilmeyen bir bellek işaretçisine veri kopyalar.

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)

Parametreler

source: Int16[]

Kopyalanacak tek boyutlu dizi.

startIndex: Int32

Kaynak dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

destination: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentOutOfRangeException

startIndex ve length geçerli değildir.

ArgumentNullException

source, startIndex, destinationveya length şeklindedir null.

Örnekler

Aşağıdaki örnek bir diziyi yönetilmeyen belleğe kopyalar ve ardından yönetilmeyen diziyi yönetilen belleğe geri kopyalar.

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

Açıklamalar

Tek boyutlu yönetilen bir dizinin alt kümesini yönetilmeyen C stili bir diziye kopyalamak için bu yöntemi kullanabilirsiniz.

Şunlara uygulanır

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Tek boyutlu, yönetilen çift duyarlıklı kayan noktalı sayı dizisinden yönetilmeyen bir bellek işaretçisine veri kopyalar.

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)

Parametreler

source: Double[]

Kopyalanacak tek boyutlu dizi.

startIndex: Int32

Kaynak dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

destination: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentOutOfRangeException

startIndex ve length geçerli değildir.

ArgumentNullException

source, startIndex, destinationveya length şeklindedir null.

Örnekler

Aşağıdaki örnek bir diziyi yönetilmeyen belleğe kopyalar ve ardından yönetilmeyen diziyi yönetilen belleğe geri kopyalar.

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

Açıklamalar

Tek boyutlu yönetilen bir dizinin alt kümesini yönetilmeyen C stili bir diziye kopyalamak için bu yöntemi kullanabilirsiniz.

Şunlara uygulanır

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Tek boyutlu, yönetilen karakter dizisinden yönetilmeyen bir bellek işaretçisine veri kopyalar.

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)

Parametreler

source: Char[]

Kopyalanacak tek boyutlu dizi.

startIndex: Int32

Kaynak dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

destination: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentOutOfRangeException

startIndex ve length geçerli değildir.

ArgumentNullException

startIndex, destinationveya length şeklindedir null.

Örnekler

Aşağıdaki örnek bir diziyi yönetilmeyen belleğe kopyalar ve ardından yönetilmeyen diziyi yönetilen belleğe geri kopyalar.

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

Açıklamalar

Tek boyutlu yönetilen bir dizinin alt kümesini yönetilmeyen C stili bir diziye kopyalamak için bu yöntemi kullanabilirsiniz.

Şunlara uygulanır

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Yönetilmeyen bir bellek işaretçisinden yönetilen karakter dizisine veri kopyalar.

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)

Parametreler

source: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

destination: Char[]

Kopyalanacak dizi.

startIndex: Int32

Hedef dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentNullException

source, destination, startIndexveya length şeklindedir null.

Örnekler

Aşağıdaki örnek bir diziyi yönetilmeyen belleğe kopyalar ve ardından yönetilmeyen diziyi yönetilen belleğe geri kopyalar.

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

Açıklamalar

Ayrıca bkz.

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

Şunlara uygulanır

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

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Kaynak:: Marshal.cs

Tek boyutlu, yönetilen 8 bit imzasız tamsayı dizisinden yönetilmeyen bir bellek işaretçisine veri kopyalar.

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)

Parametreler

source: Byte[]

Kopyalanacak tek boyutlu dizi.

startIndex: Int32

Kaynak dizide kopyalamanın başlaması gereken sıfır tabanlı dizin.

destination: IntPtr
nativeint

Kopyalanacak bellek işaretçisi.

length: Int32

Kopyalanacak dizi öğelerinin sayısı.

Öznitelikler: SecurityCriticalAttribute

Özel durumlar

ArgumentOutOfRangeException

startIndex ve length geçerli değildir.

ArgumentNullException

source, startIndex, destinationveya length şeklindedir null.

Örnekler

Aşağıdaki örnek, aşırı yüklemeyi kullanarak Copy(Byte[], Int32, IntPtr, Int32) bir diziyi yönetilmeyen belleğe kopyalar ve ardından aşırı yüklemeyi kullanarak yönetilmeyen diziyi Copy(IntPtr, Byte[], Int32, Int32) yönetilen belleğe geri kopyalar.

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

Açıklamalar

Tek boyutlu yönetilen bir dizinin alt kümesini yönetilmeyen C stili bir diziye kopyalamak için bu yöntemi kullanabilirsiniz.

Şunlara uygulanır

Aracılığıyla paylaş

Marshal.Copy Yöntem

Tanım

Aşırı Yüklemeler

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

Parametreler

Özel durumlar

Açıklamalar

Şunlara uygulanır

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

Parametreler

Özel durumlar

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

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

Parametreler

Özel durumlar

Açıklamalar

Şunlara uygulanır

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

Parametreler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

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

Parametreler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

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

Parametreler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

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

Parametreler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

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

Parametreler

Özel durumlar

Açıklamalar

Şunlara uygulanır

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

Parametreler

Özel durumlar

Örnekler

Açıklamalar

Ayrıca bkz.

Şunlara uygulanır

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

Parametreler

Özel durumlar

Örnekler

Açıklamalar

Şunlara uygulanır

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

Parametreler

Özel durumlar

Örnekler

Açıklamalar

Şunlara uygulanır

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

Parametreler

Özel durumlar

Örnekler

Açıklamalar

Şunlara uygulanır

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

Parametreler