Marshal.PtrToStructure Marshal.PtrToStructure Marshal.PtrToStructure Marshal.PtrToStructure Method

Definition

Marshals data from an unmanaged block of memory to a managed object.

Overloads

PtrToStructure(IntPtr, Object) PtrToStructure(IntPtr, Object) PtrToStructure(IntPtr, Object) PtrToStructure(IntPtr, Object)

Marshals data from an unmanaged block of memory to a managed object.

PtrToStructure(IntPtr, Type) PtrToStructure(IntPtr, Type) PtrToStructure(IntPtr, Type) PtrToStructure(IntPtr, Type)

Marshals data from an unmanaged block of memory to a newly allocated managed object of the specified type.

PtrToStructure<T>(IntPtr) PtrToStructure<T>(IntPtr) PtrToStructure<T>(IntPtr) PtrToStructure<T>(IntPtr)

[Supported in the .NET Framework 4.5.1 and later versions]

Marshals data from an unmanaged block of memory to a newly allocated managed object of the type specified by a generic type parameter.

PtrToStructure<T>(IntPtr, T) PtrToStructure<T>(IntPtr, T) PtrToStructure<T>(IntPtr, T) PtrToStructure<T>(IntPtr, T)

[Supported in the .NET Framework 4.5.1 and later versions]

Marshals data from an unmanaged block of memory to a managed object of the specified type.

PtrToStructure(IntPtr, Object) PtrToStructure(IntPtr, Object) PtrToStructure(IntPtr, Object) PtrToStructure(IntPtr, Object)

Warning

This API is now obsolete.

Marshals data from an unmanaged block of memory to a managed object.

public:
 static void PtrToStructure(IntPtr ptr, System::Object ^ structure);
[System.Runtime.InteropServices.ComVisible(true)]
[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);
static member PtrToStructure : nativeint * obj -> unit
Public Shared Sub PtrToStructure (ptr As IntPtr, structure As Object)
Parameters
ptr
IntPtr IntPtr IntPtr IntPtr

A pointer to an unmanaged block of memory.

structure
Object Object Object Object

The object to which the data is to be copied. This must be an instance of a formatted class.

Exceptions

Structure layout is not sequential or explicit.

-or-

Structure is a boxed value type.

Remarks

PtrToStructure is often necessary in COM interop and platform invoke when structure parameters are represented as an System.IntPtr value. You cannot use this overload method with value types.

Security

SecurityCriticalAttribute
requires full trust for the immediate caller. This member cannot be used by partially trusted or transparent code.

PtrToStructure(IntPtr, Type) PtrToStructure(IntPtr, Type) PtrToStructure(IntPtr, Type) PtrToStructure(IntPtr, Type)

Warning

This API is now obsolete.

Marshals data from an unmanaged block of memory to a newly allocated managed object of the specified type.

public:
 static System::Object ^ PtrToStructure(IntPtr ptr, Type ^ structureType);
[System.Runtime.InteropServices.ComVisible(true)]
[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);
static member PtrToStructure : nativeint * Type -> obj
Public Shared Function PtrToStructure (ptr As IntPtr, structureType As Type) As Object
Parameters
ptr
IntPtr IntPtr IntPtr IntPtr

A pointer to an unmanaged block of memory.

structureType
Type Type Type Type

The type of object to be created. This object must represent a formatted class or a structure.

Returns

A managed object containing the data pointed to by the ptr parameter.

Exceptions

The structureType parameter layout is not sequential or explicit.

-or-

The structureType parameter is a generic type definition.

The class specified by structureType does not have an accessible default constructor.

Examples

The following example creates a managed structure, transfers it to unmanaged memory, and then transfers it back to managed memory using the PtrToStructure method.

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


The following example demonstrates how to marshal an unmanaged block of memory to a managed structure using the PtrToStructure method.

Important

This code assumes 32-bit compilation. Before using a 64-bit compiler, replace IntPtr.ToInt32 with 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);

		}

Remarks

PtrToStructure is often necessary in COM interop and platform invoke when structure parameters are represented as an System.IntPtr value. You can pass a value type to this overload method. In this case, the returned object is a boxed instance.

Security

SecurityCriticalAttribute
requires full trust for the immediate caller. This member cannot be used by partially trusted or transparent code.

See Also

PtrToStructure<T>(IntPtr) PtrToStructure<T>(IntPtr) PtrToStructure<T>(IntPtr) PtrToStructure<T>(IntPtr)

[Supported in the .NET Framework 4.5.1 and later versions]

Marshals data from an unmanaged block of memory to a newly allocated managed object of the type specified by a generic type parameter.

public:
generic <typename T>
 static T PtrToStructure(IntPtr ptr);
[System.Security.SecurityCritical]
public static T PtrToStructure<T> (IntPtr ptr);
static member PtrToStructure : nativeint -> 'T
Public Shared Function PtrToStructure(Of T) (ptr As IntPtr) As T
Type Parameters
T

The type of the object to which the data is to be copied. This must be a formatted class or a structure.

Parameters
ptr
IntPtr IntPtr IntPtr IntPtr

A pointer to an unmanaged block of memory.

Returns

A managed object that contains the data that the ptr parameter points to.

Exceptions

The layout of T is not sequential or explicit.

The class specified by T does not have an accessible default constructor.

Remarks

PtrToStructure<T>(IntPtr) is often necessary in COM interop and platform invoke when structure parameters are represented as System.IntPtr values. You can pass a value type to this method overload.

Security

SecurityCriticalAttribute
requires full trust for the immediate caller. This member cannot be used by partially trusted or transparent code.

PtrToStructure<T>(IntPtr, T) PtrToStructure<T>(IntPtr, T) PtrToStructure<T>(IntPtr, T) PtrToStructure<T>(IntPtr, T)

[Supported in the .NET Framework 4.5.1 and later versions]

Marshals data from an unmanaged block of memory to a managed object of the specified type.

public:
generic <typename T>
 static void PtrToStructure(IntPtr ptr, T structure);
[System.Security.SecurityCritical]
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)
Type Parameters
T

The type of structure. This must be a formatted class.

Parameters
ptr
IntPtr IntPtr IntPtr IntPtr

A pointer to an unmanaged block of memory.

structure

The object to which the data is to be copied.

Exceptions

Structure layout is not sequential or explicit.

Remarks

PtrToStructure<T>(IntPtr, T) is often necessary in COM interop and platform invoke when structure parameters are represented as IntPtr values. You cannot use this method overload with value types.

Security

SecurityCriticalAttribute
requires full trust for the immediate caller. This member cannot be used by partially trusted or transparent code.

Applies to