Marshal.WriteIntPtr Méthode

Définition

Espace de noms:: System.Runtime.InteropServices

Assemblys:: mscorlib.dll, System.Runtime.InteropServices.dll

Assemblys:: netstandard.dll, System.Runtime.InteropServices.dll

Assembly:: System.Runtime.InteropServices.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Écrit une valeur entière de taille native du processeur dans la mémoire non managée. Les entiers 32 bits sont écrits sur des systèmes 32 bits et des entiers 64 bits sont écrits sur des systèmes 64 bits. L’écriture dans des emplacements de mémoire non alignés est prise en charge.

Surcharges

Nom	Description
WriteIntPtr(IntPtr, IntPtr)	Écrit une valeur entière de taille native du processeur dans la mémoire non managée.
WriteIntPtr(IntPtr, Int32, IntPtr)	Écrit une valeur entière de taille native du processeur dans une mémoire non managée à un décalage spécifié.
WriteIntPtr(Object, Int32, IntPtr)	Obsolète. Écrit une valeur entière de taille native du processeur dans la mémoire non managée.

WriteIntPtr(IntPtr, IntPtr)

Source:: Marshal.cs

Source:: Marshal.cs

Source:: Marshal.cs

Source:: Marshal.cs

Source:: Marshal.cs

Écrit une valeur entière de taille native du processeur dans la mémoire non managée.

public:
 static void WriteIntPtr(IntPtr ptr, IntPtr val);

[System.Security.SecurityCritical]
public static void WriteIntPtr(IntPtr ptr, IntPtr val);

public static void WriteIntPtr(IntPtr ptr, IntPtr val);

[<System.Security.SecurityCritical>]
static member WriteIntPtr : nativeint * nativeint -> unit

static member WriteIntPtr : nativeint * nativeint -> unit

Public Shared Sub WriteIntPtr (ptr As IntPtr, val As IntPtr)

Paramètres

ptr: IntPtr
nativeint

Adresse dans la mémoire non managée dans laquelle écrire.

val: IntPtr
nativeint

Valeur à écrire.

Attributs: SecurityCriticalAttribute

Exceptions

AccessViolationException

ptr n’est pas un format reconnu.

- ou -

ptr a la valeur null.

- ou -

ptr n’est pas valide.

Exemples

L’exemple suivant montre comment lire et écrire dans un tableau non managé à l’aide des méthodes et ReadIntPtr des WriteIntPtr méthodes.

static void ReadWriteIntPtr()
{
    // Allocate unmanaged memory. 
    int elementSize = Marshal.SizeOf(typeof(IntPtr));
    IntPtr unmanagedArray = Marshal.AllocHGlobal(10 * elementSize);

    // Set the 10 elements of the C-style unmanagedArray
    for (int i = 0; i < 10; i++)
    {
        Marshal.WriteIntPtr(unmanagedArray, i * elementSize, ((IntPtr)(i + 1)));
    }
    Console.WriteLine("Unmanaged memory written.");

    Console.WriteLine("Reading unmanaged memory:");
    // Print the 10 elements of the C-style unmanagedArray
    for (int i = 0; i < 10; i++)
    {
        Console.WriteLine(Marshal.ReadIntPtr(unmanagedArray, i * elementSize));
    }

    Marshal.FreeHGlobal(unmanagedArray);

    Console.WriteLine("Done. Press Enter to continue.");
    Console.ReadLine();
}

Sub ReadWriteIntPtr()
    ' Allocate unmanaged memory.
    Dim elementSize As Integer = Marshal.SizeOf(GetType(IntPtr))
    Dim unmanagedArray As IntPtr = Marshal.AllocHGlobal(10 * elementSize)

    ' Set the 10 elements of the C-style unmanagedArray
    For i As Integer = 0 To 9
        Marshal.WriteIntPtr(unmanagedArray, i * elementSize, CType(i + 1, IntPtr))
    Next i
    Console.WriteLine("Unmanaged memory written.")

    Console.WriteLine("Reading unmanaged memory:")
    ' Print the 10 elements of the C-style unmanagedArray
    For i As Integer = 0 To 9
        Console.WriteLine(Marshal.ReadIntPtr(unmanagedArray, i * elementSize))
    Next i

    Marshal.FreeHGlobal(unmanagedArray)

    Console.WriteLine("Done. Press Enter to continue.")
    Console.ReadLine()
End Sub

Remarques

WriteIntPtr permet une interaction directe avec un tableau de style IntPtr C non managé, éliminant les frais de copie d’un tableau non managé (utilisant Marshal.Copy) dans un tableau managé distinct avant de définir ses valeurs d’élément.

L’écriture dans des emplacements de mémoire non alignés est prise en charge.

Voir aussi

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

S’applique à

WriteIntPtr(IntPtr, Int32, IntPtr)

Source:: Marshal.cs

Source:: Marshal.cs

Source:: Marshal.cs

Source:: Marshal.cs

Source:: Marshal.cs

Écrit une valeur entière de taille native du processeur dans une mémoire non managée à un décalage spécifié.

public:
 static void WriteIntPtr(IntPtr ptr, int ofs, IntPtr val);

[System.Security.SecurityCritical]
public static void WriteIntPtr(IntPtr ptr, int ofs, IntPtr val);

public static void WriteIntPtr(IntPtr ptr, int ofs, IntPtr val);

[<System.Security.SecurityCritical>]
static member WriteIntPtr : nativeint * int * nativeint -> unit

static member WriteIntPtr : nativeint * int * nativeint -> unit

Public Shared Sub WriteIntPtr (ptr As IntPtr, ofs As Integer, val As IntPtr)

Paramètres

ptr: IntPtr
nativeint

Adresse de base dans la mémoire non managée dans laquelle écrire.

ofs: Int32

Décalage d’octet supplémentaire, ajouté au paramètre avant l’écriture ptr .

val: IntPtr
nativeint

Valeur à écrire.

Attributs: SecurityCriticalAttribute

Exceptions

AccessViolationException

L’adresse de base (ptr) plus l’octet de décalage (ofs) produit une adresse null ou non valide.

Exemples

L’exemple suivant montre comment lire et écrire dans un tableau non managé à l’aide des méthodes et ReadIntPtr des WriteIntPtr méthodes.

static void ReadWriteIntPtr()
{
    // Allocate unmanaged memory. 
    int elementSize = Marshal.SizeOf(typeof(IntPtr));
    IntPtr unmanagedArray = Marshal.AllocHGlobal(10 * elementSize);

    // Set the 10 elements of the C-style unmanagedArray
    for (int i = 0; i < 10; i++)
    {
        Marshal.WriteIntPtr(unmanagedArray, i * elementSize, ((IntPtr)(i + 1)));
    }
    Console.WriteLine("Unmanaged memory written.");

    Console.WriteLine("Reading unmanaged memory:");
    // Print the 10 elements of the C-style unmanagedArray
    for (int i = 0; i < 10; i++)
    {
        Console.WriteLine(Marshal.ReadIntPtr(unmanagedArray, i * elementSize));
    }

    Marshal.FreeHGlobal(unmanagedArray);

    Console.WriteLine("Done. Press Enter to continue.");
    Console.ReadLine();
}

Sub ReadWriteIntPtr()
    ' Allocate unmanaged memory.
    Dim elementSize As Integer = Marshal.SizeOf(GetType(IntPtr))
    Dim unmanagedArray As IntPtr = Marshal.AllocHGlobal(10 * elementSize)

    ' Set the 10 elements of the C-style unmanagedArray
    For i As Integer = 0 To 9
        Marshal.WriteIntPtr(unmanagedArray, i * elementSize, CType(i + 1, IntPtr))
    Next i
    Console.WriteLine("Unmanaged memory written.")

    Console.WriteLine("Reading unmanaged memory:")
    ' Print the 10 elements of the C-style unmanagedArray
    For i As Integer = 0 To 9
        Console.WriteLine(Marshal.ReadIntPtr(unmanagedArray, i * elementSize))
    Next i

    Marshal.FreeHGlobal(unmanagedArray)

    Console.WriteLine("Done. Press Enter to continue.")
    Console.ReadLine()
End Sub

Remarques

Cette méthode écrit un entier 32 bits sur des systèmes 32 bits et un entier 64 bits sur des systèmes 64 bits.

L’écriture dans des emplacements de mémoire non alignés est prise en charge.

Voir aussi

S’applique à

WriteIntPtr(Object, Int32, IntPtr)

Source:: Marshal.cs

Source:: Marshal.cs

Source:: Marshal.cs

Source:: Marshal.cs

Source:: Marshal.cs

Attention

WriteIntPtr(Object, Int32, IntPtr) may be unavailable in future releases.

Écrit une valeur entière de taille native du processeur dans la mémoire non managée.

public:
 static void WriteIntPtr(System::Object ^ ptr, int ofs, IntPtr val);

[System.Obsolete("WriteIntPtr(Object, Int32, IntPtr) may be unavailable in future releases.")]
[System.Security.SecurityCritical]
public static void WriteIntPtr(object ptr, int ofs, IntPtr val);

[System.Obsolete("WriteIntPtr(Object, Int32, IntPtr) may be unavailable in future releases.")]
[System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Marshalling code for the object might not be available")]
public static void WriteIntPtr(object ptr, int ofs, IntPtr val);

[System.Obsolete("WriteIntPtr(Object, Int32, IntPtr) may be unavailable in future releases.")]
public static void WriteIntPtr(object ptr, int ofs, IntPtr val);

public static void WriteIntPtr(object ptr, int ofs, IntPtr val);

[System.Security.SecurityCritical]
public static void WriteIntPtr(object ptr, int ofs, IntPtr val);

[<System.Obsolete("WriteIntPtr(Object, Int32, IntPtr) may be unavailable in future releases.")>]
[<System.Security.SecurityCritical>]
static member WriteIntPtr : obj * int * nativeint -> unit

[<System.Obsolete("WriteIntPtr(Object, Int32, IntPtr) may be unavailable in future releases.")>]
[<System.Diagnostics.CodeAnalysis.RequiresDynamicCode("Marshalling code for the object might not be available")>]
static member WriteIntPtr : obj * int * nativeint -> unit

[<System.Obsolete("WriteIntPtr(Object, Int32, IntPtr) may be unavailable in future releases.")>]
static member WriteIntPtr : obj * int * nativeint -> unit

static member WriteIntPtr : obj * int * nativeint -> unit

[<System.Security.SecurityCritical>]
static member WriteIntPtr : obj * int * nativeint -> unit

Public Shared Sub WriteIntPtr (ptr As Object, ofs As Integer, val As IntPtr)

Paramètres

ptr: Object

Adresse de base en mémoire non managée de l’objet cible.

ofs: Int32

Décalage d’octet supplémentaire, ajouté au paramètre avant l’écriture ptr .

val: IntPtr
nativeint

Valeur à écrire.

Attributs: ObsoleteAttribute SecurityCriticalAttribute RequiresDynamicCodeAttribute

Exceptions

AccessViolationException

L’adresse de base (ptr) plus l’octet de décalage (ofs) produit une adresse null ou non valide.

ArgumentException

ptr est un ArrayWithOffset objet. Cette méthode n’accepte pas les ArrayWithOffset paramètres.

Remarques

WriteIntPtr permet une interaction directe avec un tableau d’octets de style C non managé, éliminant ainsi les frais de copie d’un tableau non managé entier (utilisant Marshal.Copy) sur un tableau managé distinct avant de définir ses valeurs d’élément.

L’écriture dans des emplacements de mémoire non alignés est prise en charge.

Voir aussi

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

S’applique à

Commentaires

Cette page a-t-elle été utile ?