Marshal.PtrToStructure Methode

Definition

Namespace:

System.Runtime.InteropServices

Assembly:

System.Runtime.InteropServices.dll

Marshallt Daten aus einem nicht verwalteten Speicherblock zu einem verwalteten Objekt.

Überlädt

PtrToStructure(IntPtr, Object)	Marshallt Daten aus einem nicht verwalteten Speicherblock zu einem verwalteten Objekt.
PtrToStructure(IntPtr, Type)	Marshallt Daten aus einem nicht verwalteten Speicherblock zu einem neu belegten, verwalteten Objekt des angegebenen Typs.
PtrToStructure<T>(IntPtr)	Marshallt Daten aus einem nicht verwalteten Speicherblock zu einem neu belegten, verwalteten Objekt des von einem generischen Typparameter angegebenen Typs.
PtrToStructure<T>(IntPtr, T)	Marshallt Daten aus einem nicht verwalteten Speicherblock zu einem verwalteten Objekt eines festgelegten Typs.

PtrToStructure(IntPtr, Object)

Quelle:

Marshal.cs

Marshallt Daten aus einem nicht verwalteten Speicherblock zu einem verwalteten Objekt.

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)

Parameter

ptr

IntPtr

nativeint

Ein Zeiger auf einen nicht verwalteten Speicherblock.

structure

Object

Das Objekt, in das die Daten kopiert werden sollen. Dabei muss es sich um eine Instanz einer formatierten Klasse handeln.

Ausnahmen

ArgumentException

Das Strukturlayout ist weder sequenziell noch explizit.

- oder -

Die Struktur ist ein geschachtelter Werttyp.

Hinweise

PtrToStructure ist häufig in COM-Interop- und Plattformaufrufen erforderlich, wenn Strukturparameter als System.IntPtr Wert dargestellt werden. Sie können diese Überladungsmethode nicht mit Werttypen verwenden. Wenn der ptr Parameter gleich IntPtr.Zeroist, null wird zurückgegeben.

PtrToStructure(IntPtr, Type)

Quelle:

Marshal.cs

Marshallt Daten aus einem nicht verwalteten Speicherblock zu einem neu belegten, verwalteten Objekt des angegebenen Typs.

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

Parameter

ptr

IntPtr

nativeint

Ein Zeiger auf einen nicht verwalteten Speicherblock.

structureType

Type

Der Typ des zu erstellenden Objekts. Dieses Objekt muss eine formatierte Klasse oder eine Struktur darstellen.

Gibt zurück

Object

Ein verwaltetes Objekt mit Daten, auf die der ptr-Parameter zeigt.

Ausnahmen

ArgumentException

Das structureType-Parameterlayout ist weder sequenziell noch explizit.

- oder -

Der structureType-Parameter ist eine generische Typdefinition.

ArgumentNullException

structureType ist null.

MissingMethodException

Die von structureType angegebene Klasse besitzt keinen zugänglichen parameterlosen Konstruktor.

Beispiele

Im folgenden Beispiel wird eine verwaltete Struktur erstellt, in den nicht verwalteten Arbeitsspeicher übertragen und dann mithilfe der -Methode wieder in den PtrToStructure verwalteten Arbeitsspeicher übertragen.

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

Im folgenden Beispiel wird veranschaulicht, wie sie einen nicht verwalteten Speicherblock mithilfe der -Methode in eine verwaltete Struktur marshallen PtrToStructure .

Wichtig

Dieser Code setzt eine 32-Bit-Kompilierung voraus. Ersetzen Sie vor der Verwendung eines 64-Bit-Compilers IntPtr.ToInt32 durch 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);
        }

Hinweise

PtrToStructure ist häufig in COM-Interop- und Plattformaufrufen erforderlich, wenn Strukturparameter als System.IntPtr Wert dargestellt werden. Sie können einen Werttyp an diese Überladungsmethode übergeben. In diesem Fall ist das zurückgegebene Objekt eine Boxinstanz. Wenn der ptr Parameter gleich IntPtr.Zeroist, null wird zurückgegeben.

Weitere Informationen

• GetTypeAttr(IntPtr)

PtrToStructure<T>(IntPtr)

Quelle:

Marshal.cs

Marshallt Daten aus einem nicht verwalteten Speicherblock zu einem neu belegten, verwalteten Objekt des von einem generischen Typparameter angegebenen Typs.

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

Typparameter

T

Der Typ des Objekts, in das die Daten kopiert werden sollen. Dies muss eine formatierte Klasse oder eine Struktur sein.

Parameter

ptr

IntPtr

nativeint

Ein Zeiger auf einen nicht verwalteten Speicherblock.

Gibt zurück

T

Ein verwaltetes Objekt mit Daten, auf die der ptr-Parameter zeigt.

Ausnahmen

ArgumentException

Das Layout von Tist weder sequenziell noch explizit.

MissingMethodException

Die von T angegebene Klasse besitzt keinen zugänglichen parameterlosen Konstruktor.

Hinweise

PtrToStructure<T>(IntPtr) ist häufig in COM-Interop- und Plattformaufrufen erforderlich, wenn Strukturparameter als System.IntPtr Werte dargestellt werden. Sie können einen Werttyp an diese Methodenüberladung übergeben. Wenn der ptr Parameter gleich IntPtr.Zero und T ein Verweistyp ist, null wird zurückgegeben. Wenn ptr gleich IntPtr.Zero und T ein Werttyp ist, wird ein NullReferenceException ausgelöst.

PtrToStructure<T>(IntPtr, T)

Quelle:

Marshal.cs

Marshallt Daten aus einem nicht verwalteten Speicherblock zu einem verwalteten Objekt eines festgelegten Typs.

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)

Typparameter

T

Der structure-Typ. Muss eine formatierte Klasse sein.

Parameter

ptr

IntPtr

nativeint

Ein Zeiger auf einen nicht verwalteten Speicherblock.

structure

T

Das Objekt, in das die Daten kopiert werden sollen.

Ausnahmen

ArgumentException

Das Strukturlayout ist weder sequenziell noch explizit.

Hinweise

PtrToStructure<T>(IntPtr, T) ist häufig in COM-Interop- und Plattformaufrufen erforderlich, wenn Strukturparameter als IntPtr Werte dargestellt werden. Sie können diese Methodenüberladung nicht mit Werttypen verwenden. Wenn der ptr Parameter gleich IntPtr.Zero und T ein Verweistyp ist, null wird zurückgegeben. Wenn ptr gleich IntPtr.Zero und T ein Werttyp ist, wird ein NullReferenceException ausgelöst.