Marshal.PtrToStructure 方法

定义

命名空间:

System.Runtime.InteropServices

程序集:

System.Runtime.InteropServices.dll

将数据从非托管内存块封送到托管对象。

重载

PtrToStructure(IntPtr, Object)	将数据从非托管内存块封送到托管对象。
PtrToStructure(IntPtr, Type)	将数据从非托管内存块封送到新分配的指定类型的托管对象。
PtrToStructure<T>(IntPtr)	将数据从非托管内存块封送到泛型类型参数指定的类型的新分配托管对象。
PtrToStructure<T>(IntPtr, T)	将数据从非托管内存块封送到指定类型的托管内存对象。

PtrToStructure(IntPtr, Object)

Source:

Marshal.cs

将数据从非托管内存块封送到托管对象。

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)

参数

ptr

IntPtr

nativeint

指向非托管内存块的指针。

structure

Object

将数据复制到其中的对象。 这必须是格式化类的实例。

例外

ArgumentException

结构布局不是连续或显式的。

- 或 -

结构为装箱的值类型。

注解

PtrToStructure 当结构参数表示为 System.IntPtr 值时，在 COM 互操作和平台调用中通常是必需的。 不能将此重载方法用于值类型。 ptr如果 参数等于 IntPtr.Zero，null将返回 。

PtrToStructure(IntPtr, Type)

Source:

Marshal.cs

将数据从非托管内存块封送到新分配的指定类型的托管对象。

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

参数

ptr

IntPtr

nativeint

指向非托管内存块的指针。

structureType

Type

要创建的对象的类型。 此对象必须表示格式化类或结构。

返回

Object

一个包含 ptr 参数指向的数据的托管对象。

例外

ArgumentException

structureType 参数布局不是连续或显式的。

- 或 -

structureType 参数是泛型类型定义。

ArgumentNullException

structureType 为 null。

MissingMethodException

structureType 指定的类没有可访问的无参数构造函数。

示例

以下示例创建一个托管结构，将其传输到非托管内存，然后使用 方法将其传输回托管内存 PtrToStructure 。

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

以下示例演示如何使用 PtrToStructure 方法将非托管内存块封送到托管结构。

重要

此代码假定 32 位编译。 在使用 64 位编译器之前，请将 替换为 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);
        }

注解

PtrToStructure 当结构参数表示为 System.IntPtr 值时，在 COM 互操作和平台调用中通常是必需的。 可以将值类型传递给此重载方法。 在这种情况下，返回的对象是装箱实例。 ptr如果 参数等于 IntPtr.Zero，null将返回 。

另请参阅

• GetTypeAttr(IntPtr)

PtrToStructure<T>(IntPtr)

Source:

Marshal.cs

将数据从非托管内存块封送到泛型类型参数指定的类型的新分配托管对象。

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

类型参数

T

要将数据复制到其中的对象的类型。 这必须是格式化类或结构。

参数

ptr

IntPtr

nativeint

指向非托管内存块的指针。

返回

T

一个包含 ptr 参数指向的数据的托管对象。

例外

ArgumentException

T 的布局不是连续或显式的。

MissingMethodException

T 指定的类没有可访问的无参数构造函数。

注解

PtrToStructure<T>(IntPtr) 当结构参数表示为 System.IntPtr 值时，在 COM 互操作和平台调用中通常是必需的。 可以将值类型传递给此方法重载。 ptr如果 参数等于 IntPtr.Zero 且 T 是引用类型，null则返回 。 如果 ptr 等于 IntPtr.Zero 且 T 是值类型， NullReferenceException 则引发 。

PtrToStructure<T>(IntPtr, T)

Source:

Marshal.cs

将数据从非托管内存块封送到指定类型的托管内存对象。

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)

类型参数

T

structure 的类型。 这必须是格式化的类。

参数

ptr

IntPtr

nativeint

指向非托管内存块的指针。

structure

T

将数据复制到其中的对象。

例外

ArgumentException

结构布局不是连续或显式的。

注解

PtrToStructure<T>(IntPtr, T) 当结构参数表示为 IntPtr 值时，在 COM 互操作和平台调用中通常是必需的。 不能将此方法重载用于值类型。 ptr如果 参数等于 IntPtr.Zero 且 T 是引用类型，null则返回 。 如果 ptr 等于 IntPtr.Zero 且 T 是值类型， NullReferenceException 则引发 。