Marshal.Copy Método
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Copia los datos de una matriz administrada a un puntero de memoria no administrada o de un puntero de memoria no administrada a una matriz administrada.
Copy(Single[], Int32, IntPtr, Int32) |
Copia datos de una matriz unidimensional y administrada de números de punto flotante de precisión sencilla a un puntero de memoria no administrada. |
Copy(IntPtr, Single[], Int32, Int32) |
Copia datos de un puntero de memoria no administrada a una matriz administrada de números de punto flotante de precisión sencilla. |
Copy(IntPtr, IntPtr[], Int32, Int32) |
Copia datos de un puntero de memoria no administrada a una matriz IntPtr administrada. |
Copy(IntPtr, Int64[], Int32, Int32) |
Copia datos de un puntero de memoria no administrada a una matriz administrada de enteros de 64 bits con signo. |
Copy(IntPtr, Int32[], Int32, Int32) |
Copia datos de un puntero de memoria no administrada a una matriz administrada de enteros de 32 bits con signo. |
Copy(IntPtr, Int16[], Int32, Int32) |
Copia datos de un puntero de memoria no administrada a una matriz administrada de enteros de 16 bits con signo. |
Copy(IntPtr, Double[], Int32, Int32) |
Copia datos de un puntero de memoria no administrada a una matriz administrada de números de punto flotante de precisión doble. |
Copy(IntPtr[], Int32, IntPtr, Int32) |
Copia datos de una matriz IntPtr unidimensional y administrada a un puntero de memoria no administrada. |
Copy(IntPtr, Byte[], Int32, Int32) |
Copia datos de un puntero de memoria no administrada a una matriz administrada de enteros de 8 bits sin signo. |
Copy(Int64[], Int32, IntPtr, Int32) |
Copia datos de una matriz unidimensional administrada de enteros de 64 bits con signo a un puntero de memoria no administrada. |
Copy(Int32[], Int32, IntPtr, Int32) |
Copia datos de una matriz unidimensional administrada de enteros de 32 bits con signo a un puntero de memoria no administrada. |
Copy(Int16[], Int32, IntPtr, Int32) |
Copia datos de una matriz unidimensional administrada de enteros de 16 bits con signo a un puntero de memoria no administrada. |
Copy(Double[], Int32, IntPtr, Int32) |
Copia datos de una matriz unidimensional y administrada de números de punto flotante de precisión doble a un puntero de memoria no administrada. |
Copy(Char[], Int32, IntPtr, Int32) |
Copia datos de una matriz de caracteres unidimensional y administrada a un puntero de memoria no administrada. |
Copy(IntPtr, Char[], Int32, Int32) |
Copia datos de un puntero de memoria no administrada a una matriz de caracteres administrada. |
Copy(Byte[], Int32, IntPtr, Int32) |
Copia datos de una matriz unidimensional y administrada de enteros de 8 bits sin signo a un puntero de memoria no administrada. |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de una matriz unidimensional y administrada de números de punto flotante de precisión sencilla a un puntero de memoria no administrada.
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)
Parámetros
- source
- Single[]
Matriz unidimensional de la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de origen donde debe comenzar la copia.
- destination
-
IntPtr
nativeint
Puntero de memoria en el que se va a copiar.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
startIndex
y length
no son válidos.
source
, startIndex
, destination
o length
es null
.
Comentarios
Puede usar este método para copiar un subconjunto de una matriz administrada unidimensional en una matriz de estilo C no administrada.
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de un puntero de memoria no administrada a una matriz administrada de números de punto flotante de precisión sencilla.
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)
Parámetros
- source
-
IntPtr
nativeint
Puntero de memoria del que se va a copiar.
- destination
- Single[]
Matriz en la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de destino donde debe comenzar la copia.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
source
, destination
, startIndex
o length
es null
.
Comentarios
Las matrices de estilo C no administradas no contienen información de límites, lo que impide que se validen los startIndex
parámetros y length
. Por lo tanto, los datos no administrados correspondientes al source
parámetro rellenan la matriz administrada independientemente de su utilidad. Debe inicializar la matriz administrada con el tamaño adecuado antes de llamar a este método.
Consulte también
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de un puntero de memoria no administrada a una matriz IntPtr administrada.
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)
Parámetros
- source
-
IntPtr
nativeint
Puntero de memoria del que se va a copiar.
- destination
-
IntPtr[]
nativeint[]
Matriz en la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de destino donde debe comenzar la copia.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
source
, destination
, startIndex
o length
es null
.
Comentarios
Las matrices de estilo C no administradas no contienen información de límites, lo que impide que se validen los startIndex
parámetros y length
. Por lo tanto, los datos no administrados que corresponden al source
parámetro rellenan la matriz administrada independientemente de su utilidad. Debe inicializar la matriz administrada con el tamaño adecuado antes de llamar al Marshal.Copy método .
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de un puntero de memoria no administrada a una matriz administrada de enteros de 64 bits con signo.
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)
Parámetros
- source
-
IntPtr
nativeint
Puntero de memoria del que se va a copiar.
- destination
- Int64[]
Matriz en la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de destino donde debe comenzar la copia.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
source
, destination
, startIndex
o length
es null
.
Ejemplos
En el ejemplo siguiente se copia una matriz en memoria no administrada y, a continuación, se copia la matriz no administrada en la memoria administrada.
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
Comentarios
Las matrices de estilo C no administradas no contienen información de límites, lo que impide que se validen los startIndex
parámetros y length
. Por lo tanto, los datos no administrados correspondientes alsource
parámetro rellenan la matriz administrada independientemente de su utilidad. Debe inicializar la matriz administrada con el tamaño adecuado antes de llamar a este método.
Consulte también
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de un puntero de memoria no administrada a una matriz administrada de enteros de 32 bits con signo.
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)
Parámetros
- source
-
IntPtr
nativeint
Puntero de memoria del que se va a copiar.
- destination
- Int32[]
Matriz en la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de destino donde debe comenzar la copia.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
source
, destination
, startIndex
o length
es null
.
Ejemplos
En el ejemplo siguiente se copia una matriz en memoria no administrada y, a continuación, se copia la matriz no administrada en la memoria administrada.
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
Comentarios
Las matrices de estilo C no administradas no contienen información de límites, lo que impide que se validen los startIndex
parámetros y length
. Por lo tanto, los datos no administrados correspondientes al source
parámetro rellenan la matriz administrada independientemente de su utilidad. Debe inicializar la matriz administrada con el tamaño adecuado antes de llamar a este método.
Consulte también
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de un puntero de memoria no administrada a una matriz administrada de enteros de 16 bits con signo.
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)
Parámetros
- source
-
IntPtr
nativeint
Puntero de memoria del que se va a copiar.
- destination
- Int16[]
Matriz en la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de destino donde debe comenzar la copia.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
source
, destination
, startIndex
o length
es null
.
Ejemplos
En el ejemplo siguiente se copia una matriz en memoria no administrada y, a continuación, se copia la matriz no administrada en la memoria administrada.
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
Comentarios
Las matrices de estilo C no administradas no contienen información de límites, lo que impide que se validen los startIndex
parámetros y length
. Por lo tanto, los datos no administrados correspondientes al source
parámetro rellenan la matriz administrada independientemente de su utilidad. Debe inicializar la matriz administrada con el tamaño adecuado antes de llamar a este método.
Consulte también
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de un puntero de memoria no administrada a una matriz administrada de números de punto flotante de precisión doble.
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)
Parámetros
- source
-
IntPtr
nativeint
Puntero de memoria del que se va a copiar.
- destination
- Double[]
Matriz en la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de destino donde debe comenzar la copia.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
source
, destination
, startIndex
o length
es null
.
Ejemplos
En el ejemplo siguiente se copia una matriz en memoria no administrada y, a continuación, se copia la matriz no administrada en la memoria administrada.
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
Comentarios
Las matrices de estilo C no administradas no contienen información de límites, lo que impide que se validen los startIndex
parámetros y length
. Por lo tanto, los datos no administrados correspondientes al source
parámetro rellenan la matriz administrada independientemente de su utilidad. Debe inicializar la matriz administrada con el tamaño adecuado antes de llamar a este método.
Consulte también
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de una matriz IntPtr unidimensional y administrada a un puntero de memoria no administrada.
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)
Parámetros
- source
-
IntPtr[]
nativeint[]
Matriz unidimensional de la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de origen donde debe comenzar la copia.
- destination
-
IntPtr
nativeint
Puntero de memoria en el que se va a copiar.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
source
, destination
, startIndex
o length
es null
.
Comentarios
Puede usar este método para copiar un subconjunto de una matriz administrada IntPtr unidimensional en una matriz de estilo C no administrada.
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de un puntero de memoria no administrada a una matriz administrada de enteros de 8 bits sin signo.
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)
Parámetros
- source
-
IntPtr
nativeint
Puntero de memoria del que se va a copiar.
- destination
- Byte[]
Matriz en la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de destino donde debe comenzar la copia.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
source
, destination
, startIndex
o length
es null
.
Ejemplos
En el ejemplo siguiente se copia una matriz en memoria no administrada y, a continuación, se copia la matriz no administrada en la memoria administrada.
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
Comentarios
Las matrices de estilo C no administradas no contienen información de límites, lo que impide que se validen los startIndex
parámetros y length
. Por lo tanto, los datos no administrados correspondientes al source
parámetro rellenan la matriz administrada independientemente de su utilidad. Debe inicializar la matriz administrada con el tamaño adecuado antes de llamar a este método.
Consulte también
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de una matriz unidimensional administrada de enteros de 64 bits con signo a un puntero de memoria no administrada.
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)
Parámetros
- source
- Int64[]
Matriz unidimensional de la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de origen donde debe comenzar la copia.
- destination
-
IntPtr
nativeint
Puntero de memoria en el que se va a copiar.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
startIndex
y length
no son válidos.
source
, startIndex
, destination
o length
es null
.
Ejemplos
En el ejemplo siguiente se copia una matriz en memoria no administrada y, a continuación, se copia la matriz no administrada en la memoria administrada.
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
Comentarios
Puede usar este método para copiar un subconjunto de una matriz administrada unidimensional en una matriz de estilo C no administrada.
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de una matriz unidimensional administrada de enteros de 32 bits con signo a un puntero de memoria no administrada.
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)
Parámetros
- source
- Int32[]
Matriz unidimensional de la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de origen donde debe comenzar la copia.
- destination
-
IntPtr
nativeint
Puntero de memoria en el que se va a copiar.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
startIndex
y length
no son válidos.
startIndex
o length
es null
.
Ejemplos
En el ejemplo siguiente se copia una matriz en memoria no administrada y, a continuación, se copia la matriz no administrada en la memoria administrada.
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
Comentarios
Puede usar este método para copiar un subconjunto de una matriz administrada unidimensional en una matriz de estilo C no administrada.
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de una matriz unidimensional administrada de enteros de 16 bits con signo a un puntero de memoria no administrada.
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)
Parámetros
- source
- Int16[]
Matriz unidimensional de la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de origen donde debe comenzar la copia.
- destination
-
IntPtr
nativeint
Puntero de memoria en el que se va a copiar.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
startIndex
y length
no son válidos.
source
, startIndex
, destination
o length
es null
.
Ejemplos
En el ejemplo siguiente se copia una matriz en memoria no administrada y, a continuación, se copia la matriz no administrada en la memoria administrada.
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
Comentarios
Puede usar este método para copiar un subconjunto de una matriz administrada unidimensional en una matriz de estilo C no administrada.
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de una matriz unidimensional y administrada de números de punto flotante de precisión doble a un puntero de memoria no administrada.
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)
Parámetros
- source
- Double[]
Matriz unidimensional de la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de origen donde debe comenzar la copia.
- destination
-
IntPtr
nativeint
Puntero de memoria en el que se va a copiar.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
startIndex
y length
no son válidos.
source
, startIndex
, destination
o length
es null
.
Ejemplos
En el ejemplo siguiente se copia una matriz en memoria no administrada y, a continuación, se copia la matriz no administrada en la memoria administrada.
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
Comentarios
Puede usar este método para copiar un subconjunto de una matriz administrada unidimensional en una matriz de estilo C no administrada.
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de una matriz de caracteres unidimensional y administrada a un puntero de memoria no administrada.
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)
Parámetros
- source
- Char[]
Matriz unidimensional de la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de origen donde debe comenzar la copia.
- destination
-
IntPtr
nativeint
Puntero de memoria en el que se va a copiar.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
startIndex
y length
no son válidos.
startIndex
, destination
o length
es null
.
Ejemplos
En el ejemplo siguiente se copia una matriz en memoria no administrada y, a continuación, se copia la matriz no administrada en la memoria administrada.
// 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
Comentarios
Puede usar este método para copiar un subconjunto de una matriz administrada unidimensional en una matriz de estilo C no administrada.
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de un puntero de memoria no administrada a una matriz de caracteres administrada.
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)
Parámetros
- source
-
IntPtr
nativeint
Puntero de memoria del que se va a copiar.
- destination
- Char[]
Matriz en la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de destino donde debe comenzar la copia.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
source
, destination
, startIndex
o length
es null
.
Ejemplos
En el ejemplo siguiente se copia una matriz en memoria no administrada y, a continuación, se copia la matriz no administrada en la memoria administrada.
// 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
Comentarios
Las matrices de estilo C no administradas no contienen información de límites, lo que impide que se validen los startIndex
parámetros y length
. Por lo tanto, los datos no administrados correspondientes al source
parámetro rellenan la matriz administrada independientemente de su utilidad. Debe inicializar la matriz administrada con el tamaño adecuado antes de llamar a este método.
Consulte también
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
- Source:
- Marshal.cs
- Source:
- Marshal.cs
- Source:
- Marshal.cs
Copia datos de una matriz unidimensional y administrada de enteros de 8 bits sin signo a un puntero de memoria no administrada.
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)
Parámetros
- source
- Byte[]
Matriz unidimensional de la que se va a copiar.
- startIndex
- Int32
Índice de base cero de la matriz de origen donde debe comenzar la copia.
- destination
-
IntPtr
nativeint
Puntero de memoria en el que se va a copiar.
- length
- Int32
Número de elementos de la matriz que se van a copiar.
- Atributos
Excepciones
startIndex
y length
no son válidos.
source
, startIndex
, destination
o length
es null
.
Ejemplos
En el ejemplo siguiente se copia una matriz en memoria no administrada mediante la Copy(Byte[], Int32, IntPtr, Int32) sobrecarga y, a continuación, se copia la matriz no administrada en la memoria administrada mediante la Copy(IntPtr, Byte[], Int32, Int32) sobrecarga .
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
Comentarios
Puede usar este método para copiar un subconjunto de una matriz administrada unidimensional en una matriz de estilo C no administrada.
Se aplica a
.NET 9 y otras versiones
Producto | Versiones |
---|---|
.NET | Core 1.0, Core 1.1, Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9 |
.NET Framework | 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1 |
.NET Standard | 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 2.0, 2.1 |
UWP | 10.0 |
Comentarios de .NET
.NET es un proyecto de código abierto. Seleccione un vínculo para proporcionar comentarios: