Marshal.PtrToStructure Method (IntPtr, Type)

'Declaration
<ComVisibleAttribute(True)> _
Public Shared Function PtrToStructure ( _
	ptr As IntPtr, _
	structureType As Type _
) As Object
'Usage
Dim ptr As IntPtr
Dim structureType As Type
Dim returnValue As Object

returnValue = Marshal.PtrToStructure(ptr, structureType)

/** @attribute ComVisibleAttribute(true) */ 
public static Object PtrToStructure (
	IntPtr ptr, 
	Type structureType
)

ComVisibleAttribute(true) 
public static function PtrToStructure (
	ptr : IntPtr, 
	structureType : Type
) : Object

Not applicable.

Imports System
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

/** @attribute StructLayout(LayoutKind.Sequential)
 */
public static class Inner
{
    /** @attribute MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)
     */
    public String field1 = "Test";
} //Inner

/** @attribute StructLayout(LayoutKind.Sequential)
 */
public static class Outer
{
    /** @attribute MarshalAs(UnmanagedType.ByValTStr, SizeConst = 10)
     */
    public String field1;

    /** @attribute MarshalAs(UnmanagedType.ByValArray, SizeConst = 100)
     */
    public ubyte inner[];
} //Outer

/** @attribute DllImport("SomeTestDLL.dll")
 */
public static native void CallTest(Outer po);

private 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.get_Length() * iStructSize;
    ed.inner = new ubyte[sz];
    try {
        CallTest(ed);
    }
    catch (System.Exception e) {
        Console.WriteLine(e.get_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.set_Item(i, (Inner)(Marshal.PtrToStructure(new IntPtr(
            buffer.ToInt32() + iCurOffset), Inner.class.ToType())));
        iCurOffset += iStructSize;
    }
    Console.WriteLine(ed.field1);
    Marshal.FreeCoTaskMem(buffer);
} //main