Marshal.PtrToStructure Méthode

Référence

Définition

Espace de noms:: System.Runtime.InteropServices

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.

Marshale les données d'un bloc de mémoire non managée dans un objet managé.

Surcharges

PtrToStructure(IntPtr, Object)	Obsolète. Marshale les données d'un bloc de mémoire non managée dans un objet managé.
PtrToStructure(IntPtr, Type)	Obsolète. Marshale, dans un nouvel objet managé alloué du type spécifié, les données d'un bloc de mémoire non managée.
PtrToStructure<T>(IntPtr)	Marshale, dans un nouvel objet managé alloué du type spécifié par un paramètre de type générique, les données d'un bloc de mémoire non managée.
PtrToStructure<T>(IntPtr, T)	Marshale les données d'un bloc de mémoire non managée dans un objet managé d'un type spécifié.

PtrToStructure(IntPtr, Object)

Source:: Marshal.cs

Source:: Marshal.cs

Source:: Marshal.cs

Attention

PtrToStructure(IntPtr, Object) may be unavailable in future releases. Instead, use PtrToStructure<T>(IntPtr). For more info, go to http://go.microsoft.com/fwlink/?LinkID=296512

Marshale les données d'un bloc de mémoire non managée dans un objet managé.

public:
 static void PtrToStructure(IntPtr ptr, System::Object ^ structure);

[System.Obsolete("PtrToStructure(IntPtr, Object) may be unavailable in future releases. Instead, use PtrToStructure<T>(IntPtr). For more info, go to http://go.microsoft.com/fwlink/?LinkID=296512")]
[System.Security.SecurityCritical]
public static void PtrToStructure (IntPtr ptr, object structure);

public static void PtrToStructure (IntPtr ptr, object structure);

[System.Security.SecurityCritical]
public static void PtrToStructure (IntPtr ptr, object structure);

[System.Runtime.InteropServices.ComVisible(true)]
public static void PtrToStructure (IntPtr ptr, object structure);

[System.Security.SecurityCritical]
[System.Runtime.InteropServices.ComVisible(true)]
public static void PtrToStructure (IntPtr ptr, object structure);

[<System.Obsolete("PtrToStructure(IntPtr, Object) may be unavailable in future releases. Instead, use PtrToStructure<T>(IntPtr). For more info, go to http://go.microsoft.com/fwlink/?LinkID=296512")>]
[<System.Security.SecurityCritical>]
static member PtrToStructure : nativeint * obj -> unit

static member PtrToStructure : nativeint * obj -> unit

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

[<System.Runtime.InteropServices.ComVisible(true)>]
static member PtrToStructure : nativeint * obj -> unit

[<System.Security.SecurityCritical>]
[<System.Runtime.InteropServices.ComVisible(true)>]
static member PtrToStructure : nativeint * obj -> unit

Public Shared Sub PtrToStructure (ptr As IntPtr, structure As Object)

Paramètres

ptr: IntPtr
nativeint

Pointeur vers un bloc de mémoire non managée.

structure: Object

Objet dans lequel les données doivent être copiées. Il doit s'agir d'une instance d'une classe mise en forme.

Attributs: ObsoleteAttribute SecurityCriticalAttribute ComVisibleAttribute

Exceptions

ArgumentException

La disposition de structure n'est ni séquentielle ni explicite.

- ou -

La structure est un type valeur boxed.

Remarques

PtrToStructure est souvent nécessaire dans l’interopérabilité COM et l’appel de plateforme lorsque les paramètres de structure sont représentés en tant que System.IntPtr valeur. Vous ne pouvez pas utiliser cette méthode de surcharge avec des types valeur. Si le ptr paramètre est égal IntPtr.Zeroà , null est retourné.

S’applique à

PtrToStructure(IntPtr, Type)

Source:: Marshal.cs

Source:: Marshal.cs

Source:: Marshal.cs

Attention

PtrToStructure(IntPtr, Type) may be unavailable in future releases. Instead, use PtrToStructure<T>(IntPtr). For more info, go to http://go.microsoft.com/fwlink/?LinkID=296513

Marshale, dans un nouvel objet managé alloué du type spécifié, les données d'un bloc de mémoire non managée.

public:
 static System::Object ^ PtrToStructure(IntPtr ptr, Type ^ structureType);

[System.Obsolete("PtrToStructure(IntPtr, Type) may be unavailable in future releases. Instead, use PtrToStructure<T>(IntPtr). For more info, go to http://go.microsoft.com/fwlink/?LinkID=296513")]
[System.Security.SecurityCritical]
public static object PtrToStructure (IntPtr ptr, Type structureType);

public static object? PtrToStructure (IntPtr ptr, Type structureType);

[System.Security.SecurityCritical]
public static object PtrToStructure (IntPtr ptr, Type structureType);

public static object PtrToStructure (IntPtr ptr, Type structureType);

[System.Runtime.InteropServices.ComVisible(true)]
public static object PtrToStructure (IntPtr ptr, Type structureType);

[System.Security.SecurityCritical]
[System.Runtime.InteropServices.ComVisible(true)]
public static object PtrToStructure (IntPtr ptr, Type structureType);

[<System.Obsolete("PtrToStructure(IntPtr, Type) may be unavailable in future releases. Instead, use PtrToStructure<T>(IntPtr). For more info, go to http://go.microsoft.com/fwlink/?LinkID=296513")>]
[<System.Security.SecurityCritical>]
static member PtrToStructure : nativeint * Type -> obj

static member PtrToStructure : nativeint * Type -> obj

[<System.Security.SecurityCritical>]
static member PtrToStructure : nativeint * Type -> obj

[<System.Runtime.InteropServices.ComVisible(true)>]
static member PtrToStructure : nativeint * Type -> obj

[<System.Security.SecurityCritical>]
[<System.Runtime.InteropServices.ComVisible(true)>]
static member PtrToStructure : nativeint * Type -> obj

Public Shared Function PtrToStructure (ptr As IntPtr, structureType As Type) As Object

Paramètres

ptr: IntPtr
nativeint

Pointeur vers un bloc de mémoire non managée.

structureType: Type

Type d'objet à créer. Cet objet doit représenter une classe mise en forme ou une structure.

Retours

Object

Objet managé contenant les données vers lesquelles pointe le paramètre ptr.

Attributs: ObsoleteAttribute SecurityCriticalAttribute ComVisibleAttribute

Exceptions

ArgumentException

La disposition du paramètre structureType n'est ni séquentielle ni explicite.

- ou -

Le paramètre structureType est une définition de type générique.

ArgumentNullException

structureType a la valeur null.

MissingMethodException

La classe spécifiée par structureType n’a pas de constructeur sans paramètre accessible.

Exemples

L’exemple suivant crée une structure managée, la transfère à la mémoire non managée, puis la transfère à la mémoire managée à l’aide de la PtrToStructure méthode .

using System;
using System.Runtime.InteropServices;

public struct Point
{
    public int x;
    public int y;
}

class Example
{

    static void Main()
    {

        // Create a point struct.
        Point p;
        p.x = 1;
        p.y = 1;

        Console.WriteLine("The value of first point is " + p.x + " and " + p.y + ".");

        // Initialize unmanged memory to hold the struct.
        IntPtr pnt = Marshal.AllocHGlobal(Marshal.SizeOf(p));

        try
        {

            // Copy the struct to unmanaged memory.
            Marshal.StructureToPtr(p, pnt, false);

            // Create another point.
            Point anotherP;

            // Set this Point to the value of the
            // Point in unmanaged memory.
            anotherP = (Point)Marshal.PtrToStructure(pnt, typeof(Point));

            Console.WriteLine("The value of new point is " + anotherP.x + " and " + anotherP.y + ".");
        }
        finally
        {
            // Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt);
        }
    }
}

Imports System.Runtime.InteropServices



Public Structure Point
    Public x As Integer
    Public y As Integer
End Structure


Module Example


    Sub Main()

        ' Create a point struct.
        Dim p As Point
        p.x = 1
        p.y = 1

        Console.WriteLine("The value of first point is " + p.x.ToString + " and " + p.y.ToString + ".")

        ' Initialize unmanged memory to hold the struct.
        Dim pnt As IntPtr = Marshal.AllocHGlobal(Marshal.SizeOf(p))

        Try

            ' Copy the struct to unmanaged memory.
            Marshal.StructureToPtr(p, pnt, False)

            ' Create another point.
            Dim anotherP As Point

            ' Set this Point to the value of the 
            ' Point in unmanaged memory. 
            anotherP = CType(Marshal.PtrToStructure(pnt, GetType(Point)), Point)

            Console.WriteLine("The value of new point is " + anotherP.x.ToString + " and " + anotherP.y.ToString + ".")

        Finally
            ' Free the unmanaged memory.
            Marshal.FreeHGlobal(pnt)
        End Try

    End Sub
End Module

L’exemple suivant montre comment marshaler un bloc de mémoire non managé vers une structure managée à l’aide de la PtrToStructure méthode .

Important

Ce code suppose une compilation 32 bits. Avant d’utiliser un compilateur 64 bits, remplacez par IntPtr.ToInt32 IntPtr.ToInt64.

[StructLayout(LayoutKind::Sequential)]
ref class INNER
{
public:
    [MarshalAs(UnmanagedType::ByValTStr,SizeConst=10)]
    String^ field;

    INNER()
    {
        field = "Test";
    }
};

[StructLayout(LayoutKind::Sequential)]
value struct OUTER
{
public:
    [MarshalAs(UnmanagedType::ByValTStr,SizeConst=10)]
    String^ field;

    [MarshalAs(UnmanagedType::ByValArray,SizeConst=100)]
    array<Byte>^ inner;
};

[DllImport("SomeTestDLL.dll")]
static void CallTest(OUTER^ outerStructurePointer);

void static Work()
{
    OUTER outerStructure;
    array<INNER^>^ innerArray = gcnew array<INNER^>(10);
    INNER^ innerStructure = gcnew INNER;
    int structSize = Marshal::SizeOf(innerStructure);
    int size = innerArray->Length * structSize;
    outerStructure.inner = gcnew array<Byte>(size);

    try
    {
        CallTest(outerStructure);
    }
    catch (SystemException^ ex) 
    {
        Console::WriteLine(ex->Message);
    }

    IntPtr buffer = Marshal::AllocCoTaskMem(structSize * 10);
    Marshal::Copy(outerStructure.inner, 0, buffer, structSize * 10);
    int currentOffset = 0;
    for (int i = 0; i < 10; i++)
    {
        innerArray[i] = safe_cast<INNER^>(Marshal::PtrToStructure(
            IntPtr(buffer.ToInt32() + currentOffset),
            INNER::typeid));
        currentOffset += structSize;
    }
    Console::WriteLine(outerStructure.field);
    Marshal::FreeCoTaskMem(buffer);
}


        [StructLayout(LayoutKind.Sequential)]

        public class  INNER

        {

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst =  10)]

            public string field1 = "Test";
        }	

        [StructLayout(LayoutKind.Sequential)]

        public struct OUTER

        {

            [MarshalAs(UnmanagedType.ByValTStr, SizeConst =  10)]

            public string field1;

            [MarshalAs(UnmanagedType.ByValArray, SizeConst =  100)]

            public byte[] inner;
        }
        [DllImport(@"SomeTestDLL.dll")]

        public static extern void CallTest( ref OUTER po);
        static void Main(string[] args)

        {

            OUTER ed = new OUTER();

            INNER[] inn=new INNER[10];

            INNER test = new INNER();

            int iStructSize = Marshal.SizeOf(test);
            int sz =inn.Length * iStructSize;

            ed.inner = new byte[sz];
            try

            {

                CallTest( ref ed);
            }

            catch(Exception e)

            {

                Console.WriteLine(e.Message);
            }

            IntPtr buffer = Marshal.AllocCoTaskMem(iStructSize*10);

            Marshal.Copy(ed.inner,0,buffer,iStructSize*10);
            int iCurOffset = 0;

            for(int i=0;i<10;i++)

            {
                inn[i] = (INNER)Marshal.PtrToStructure(new
IntPtr(buffer.ToInt32()+iCurOffset),typeof(INNER) );

                iCurOffset += iStructSize;
            }

            Console.WriteLine(ed.field1);

            Marshal.FreeCoTaskMem(buffer);
        }

Remarques

PtrToStructure est souvent nécessaire dans l’interopérabilité COM et l’appel de plateforme lorsque les paramètres de structure sont représentés en tant que System.IntPtr valeur. Vous pouvez passer un type valeur à cette méthode de surcharge. Dans ce cas, l’objet retourné est un instance en boîte. Si le ptr paramètre est égal IntPtr.Zeroà , null est retourné.

Voir aussi

GetTypeAttr(IntPtr)

S’applique à

PtrToStructure<T>(IntPtr)

Source:: Marshal.cs

Source:: Marshal.cs

Source:: Marshal.cs

Marshale, dans un nouvel objet managé alloué du type spécifié par un paramètre de type générique, les données d'un bloc de mémoire non managée.

public:
generic <typename T>
 static T PtrToStructure(IntPtr ptr);

[System.Security.SecurityCritical]
public static T PtrToStructure<T> (IntPtr ptr);

public static T? PtrToStructure<T> (IntPtr ptr);

public static T PtrToStructure<T> (IntPtr ptr);

[<System.Security.SecurityCritical>]
static member PtrToStructure : nativeint -> 'T

static member PtrToStructure : nativeint -> 'T

Public Shared Function PtrToStructure(Of T) (ptr As IntPtr) As T

Paramètres de type

T

Type de l'objet dans lequel les données doivent être copiées. Il doit s'agir d'une classe ou d'une structure mise en forme.

Paramètres

ptr: IntPtr
nativeint

Pointeur vers un bloc de mémoire non managée.

Retours

Objet managé contenant les données vers lesquelles pointe le paramètre ptr.

Attributs: SecurityCriticalAttribute

Exceptions

ArgumentException

La disposition de T n'est ni séquentielle ni explicite.

MissingMethodException

La classe spécifiée par T n’a pas de constructeur sans paramètre accessible.

Remarques

PtrToStructure<T>(IntPtr) est souvent nécessaire dans l’interopérabilité COM et l’appel de plateforme lorsque les paramètres de structure sont représentés sous forme System.IntPtr de valeurs. Vous pouvez passer un type de valeur à cette surcharge de méthode. Si le ptr paramètre est IntPtr.Zero égal à et T est un type de référence, null est retourné. Si ptr est IntPtr.Zero égal à et T est un type valeur, un NullReferenceException est levée.

S’applique à

PtrToStructure<T>(IntPtr, T)

Source:: Marshal.cs

Source:: Marshal.cs

Source:: Marshal.cs

Marshale les données d'un bloc de mémoire non managée dans un objet managé d'un type spécifié.

public:
generic <typename T>
 static void PtrToStructure(IntPtr ptr, T structure);

[System.Security.SecurityCritical]
public static void PtrToStructure<T> (IntPtr ptr, T structure);

public static void PtrToStructure<T> (IntPtr ptr, T structure);

[<System.Security.SecurityCritical>]
static member PtrToStructure : nativeint * 'T -> unit

static member PtrToStructure : nativeint * 'T -> unit

Public Shared Sub PtrToStructure(Of T) (ptr As IntPtr, structure As T)

Paramètres de type

T

Type d'élément structure. Il doit s'agir d'une classe formatée.

Paramètres

ptr: IntPtr
nativeint

Pointeur vers un bloc de mémoire non managée.

structure: T

Objet dans lequel les données doivent être copiées.

Attributs: SecurityCriticalAttribute

Exceptions

ArgumentException

La disposition de structure n'est ni séquentielle ni explicite.

Remarques

PtrToStructure<T>(IntPtr, T) est souvent nécessaire dans l’interopérabilité COM et l’appel de plateforme lorsque les paramètres de structure sont représentés sous forme IntPtr de valeurs. Vous ne pouvez pas utiliser cette surcharge de méthode avec des types valeur. Si le ptr paramètre est IntPtr.Zero égal à et T est un type de référence, null est retourné. Si ptr est IntPtr.Zero égal à et T est un type valeur, un NullReferenceException est levée.

S’applique à

Marshal.PtrToStructure Méthode

Définition

Surcharges

PtrToStructure(IntPtr, Object)

Paramètres

Exceptions

Remarques

S’applique à

PtrToStructure(IntPtr, Type)

Paramètres

Retours

Exceptions

Exemples

Remarques

Voir aussi

S’applique à

PtrToStructure<T>(IntPtr)

Paramètres de type

Paramètres

Retours

Exceptions

Remarques

S’applique à

PtrToStructure<T>(IntPtr, T)

Paramètres de type

Paramètres

Exceptions

Remarques

S’applique à

Commentaires

Ressources supplémentaires