Marshal.PtrToStructure Méthode

Définition

Espace de noms:

System.Runtime.InteropServices

Assembly:

System.Runtime.InteropServices.dll

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

Surcharges

PtrToStructure(IntPtr, Object)	Marshale les données d'un bloc de mémoire non managée dans un objet managé.
PtrToStructure(IntPtr, Type)	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

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);

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

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.

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 sous la forme d’une 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é.

PtrToStructure(IntPtr, Type)

Source:

Marshal.cs

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);

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

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.

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é dans 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.ToInt32IntPtr.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 sous la forme d’une System.IntPtr valeur. Vous pouvez passer un type valeur à cette méthode de surcharge. Dans ce cas, l’objet retourné est une instance boxed. Si le ptr paramètre est égal IntPtr.Zeroà , null est retourné.

Voir aussi

• GetTypeAttr(IntPtr)

PtrToStructure<T>(IntPtr)

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);

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

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

T

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

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 valeur à cette surcharge de méthode. Si le ptr paramètre est égal IntPtr.Zero à et T est un type référence, null est retourné. Si ptr est IntPtr.Zero égal à et T est un type valeur, un NullReferenceException est levée.

PtrToStructure<T>(IntPtr, T)

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);

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

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.

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 égal IntPtr.Zero à et T est un type référence, null est retourné. Si ptr est IntPtr.Zero égal à et T est un type valeur, un NullReferenceException est levée.