Marshal.ReadInt32 Méthode

Définition

Espace de noms:: System.Runtime.InteropServices

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

Assembly:: mscorlib.dll

Assembly:: System.Runtime.InteropServices.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.

Lit un entier signé 32 bits à partir de la mémoire non managée. La lecture à partir d’emplacements de mémoire non alignés est prise en charge.

Surcharges

Nom	Description
ReadInt32(IntPtr)	Lit un entier signé 32 bits à partir de la mémoire non managée.
ReadInt32(IntPtr, Int32)	Lit un entier signé 32 bits à un décalage donné de la mémoire non managée.
ReadInt32(Object, Int32)	Obsolète. Lit un entier signé 32 bits à un décalage donné de la mémoire non managée.

ReadInt32(IntPtr)

Lit un entier signé 32 bits à partir de la mémoire non managée.

public:
 static int ReadInt32(IntPtr ptr);

[System.Security.SecurityCritical]
public static int ReadInt32(IntPtr ptr);

public static int ReadInt32(IntPtr ptr);

[<System.Security.SecurityCritical>]
static member ReadInt32 : nativeint -> int

static member ReadInt32 : nativeint -> int

Public Shared Function ReadInt32 (ptr As IntPtr) As Integer

Paramètres

ptr: IntPtr
nativeint

Adresse dans la mémoire non managée à partir de laquelle lire.

Retours

Int32

Entier signé 32 bits lu à partir de la mémoire non managée.

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 WriteInt32 des ReadInt32 méthodes.

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

    // Set the 10 elements of the C-style unmanagedArray
    for (int i = 0; i < 10; i++)
    {
        Marshal.WriteInt32(unmanagedArray, i * elementSize, ((Int32)(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.ReadInt32(unmanagedArray, i * elementSize));
    }

    Marshal.FreeHGlobal(unmanagedArray);

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

Sub ReadWriteInt32()
    ' Allocate unmanaged memory. 
    Dim elementSize As Integer = 4
    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.WriteInt32(unmanagedArray, i * elementSize, CType(i + 1, Int32))
    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.ReadInt32(unmanagedArray, i * elementSize))
    Next i

    Marshal.FreeHGlobal(unmanagedArray)

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

L’exemple suivant montre comment utiliser la ReadInt32 méthode pour lire la valeur d’une variable non managée int .

using namespace System;
using namespace System::Runtime::InteropServices;



void main()
{
    // Create an unmanaged integer.
    int myVal = 42;

    // Read the int as a managed Int32.
        Int32 ^ myManagedVal = Marshal::ReadInt32((IntPtr) &myVal);

    // Display the value to the console.
    Console::WriteLine(myManagedVal);
}

Remarques

ReadInt32 a un décalage implicite de 0. Cette méthode permet une interaction directe avec un tableau de style Int32 C non managé, éliminant ainsi les frais de copie d’un tableau non managé (utilisant Marshal.Copy) dans un tableau managé distinct avant de lire ses valeurs d’élément.

La lecture à partir d’emplacements de mémoire non alignés est prise en charge.

Voir aussi

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

S’applique à

ReadInt32(IntPtr, Int32)

Lit un entier signé 32 bits à un décalage donné de la mémoire non managée.

public:
 static int ReadInt32(IntPtr ptr, int ofs);

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

public static int ReadInt32(IntPtr ptr, int ofs);

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

static member ReadInt32 : nativeint * int -> int

Public Shared Function ReadInt32 (ptr As IntPtr, ofs As Integer) As Integer

Paramètres

ptr: IntPtr
nativeint

Adresse de base dans la mémoire non managée à partir de laquelle lire.

ofs: Int32

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

Retours

Int32

Entier signé 32 bits lu à partir de la mémoire non managée.

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 WriteInt32 des ReadInt32 méthodes.

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

    // Set the 10 elements of the C-style unmanagedArray
    for (int i = 0; i < 10; i++)
    {
        Marshal.WriteInt32(unmanagedArray, i * elementSize, ((Int32)(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.ReadInt32(unmanagedArray, i * elementSize));
    }

    Marshal.FreeHGlobal(unmanagedArray);

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

Sub ReadWriteInt32()
    ' Allocate unmanaged memory. 
    Dim elementSize As Integer = 4
    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.WriteInt32(unmanagedArray, i * elementSize, CType(i + 1, Int32))
    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.ReadInt32(unmanagedArray, i * elementSize))
    Next i

    Marshal.FreeHGlobal(unmanagedArray)

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

L’exemple suivant montre comment utiliser la ReadInt32 méthode pour lire la valeur d’une variable non managée int .

using namespace System;
using namespace System::Runtime::InteropServices;



void main()
{
    // Create an unmanaged int pointer.
    int * myVal;
    int tmp = 42;
    // Initialize it to another value.
    myVal = &tmp;

    // Read value as a managed Int32.
    Int32 ^ myManagedVal = Marshal::ReadInt32((IntPtr) myVal, 0);

    // Display the value to the console.
    Console::WriteLine(myManagedVal);
}

Remarques

ReadInt32 permet une interaction directe avec un tableau signé 32 bits non managé, éliminant les frais de copie d’un tableau non managé entier (utilisant Marshal.Copy) dans un tableau managé distinct avant de lire ses valeurs d’élément.

La lecture à partir d’emplacements de mémoire non alignés est prise en charge.

Voir aussi

S’applique à

ReadInt32(Object, Int32)

Attention

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

Lit un entier signé 32 bits à un décalage donné de la mémoire non managée.

public:
 static int ReadInt32(System::Object ^ ptr, int ofs);

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

public static int ReadInt32(object ptr, int ofs);

[System.Security.SecurityCritical]
public static int ReadInt32(object ptr, int ofs);

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

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

static member ReadInt32 : obj * int -> int

[<System.Security.SecurityCritical>]
static member ReadInt32 : obj * int -> int

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

Public Shared Function ReadInt32 (ptr As Object, ofs As Integer) As Integer

Paramètres

ptr: Object

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

ofs: Int32

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

Retours

Int32

Entier signé 32 bits lu à partir de la mémoire non managée au décalage donné.

Attributs: ObsoleteAttribute SecurityCriticalAttribute

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

La lecture à partir d’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 ?