Marshal.PtrToStructure Metoda

Definicja

Przestrzeń nazw:

System.Runtime.InteropServices

Zestaw:

System.Runtime.InteropServices.dll

Marshaluje dane z niezarządzanego bloku pamięci do obiektu zarządzanego.

Przeciążenia

PtrToStructure(IntPtr, Object)	Marshaluje dane z niezarządzanego bloku pamięci do obiektu zarządzanego.
PtrToStructure(IntPtr, Type)	Marshaluje dane z niezarządzanego bloku pamięci do nowo przydzielonego obiektu zarządzanego określonego typu.
PtrToStructure<T>(IntPtr)	Marshaluje dane z niezarządzanego bloku pamięci do nowo przydzielonego obiektu zarządzanego typu określonego przez parametr typu ogólnego.
PtrToStructure<T>(IntPtr, T)	Marshaluje dane z niezarządzanego bloku pamięci do zarządzanego obiektu określonego typu.

PtrToStructure(IntPtr, Object)

Źródło:

Marshal.cs

Marshaluje dane z niezarządzanego bloku pamięci do obiektu zarządzanego.

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)

Parametry

ptr

IntPtr

nativeint

Wskaźnik do niezarządzanego bloku pamięci.

structure

Object

Obiekt, do którego mają zostać skopiowane dane. Musi to być wystąpienie sformatowanej klasy.

Wyjątki

ArgumentException

Układ struktury nie jest sekwencyjny ani jawny.

-lub-

Struktura jest typem wartości pola.

Uwagi

PtrToStructure jest często konieczne w przypadku międzyoperacjności modelu COM i wywołania platformy, gdy parametry struktury są reprezentowane jako System.IntPtr wartość. Nie można użyć tej metody przeciążenia z typami wartości. ptr Jeśli parametr jest równy IntPtr.Zero, null zostanie zwrócony.

PtrToStructure(IntPtr, Type)

Źródło:

Marshal.cs

Marshaluje dane z niezarządzanego bloku pamięci do nowo przydzielonego obiektu zarządzanego określonego typu.

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

Parametry

ptr

IntPtr

nativeint

Wskaźnik do niezarządzanego bloku pamięci.

structureType

Type

Typ obiektu do utworzenia. Ten obiekt musi reprezentować sformatowaną klasę lub strukturę.

Zwraca

Object

Obiekt zarządzany zawierający dane wskazywane przez ptr parametr .

Wyjątki

ArgumentException

Układ structureType parametrów nie jest sekwencyjny ani jawny.

-lub-

Parametr structureType jest definicją typu ogólnego.

ArgumentNullException

structureType to null.

MissingMethodException

Klasa określona przez structureType nie ma dostępnego konstruktora bez parametrów.

Przykłady

Poniższy przykład tworzy strukturę zarządzaną, przesyła ją do niezarządzanej pamięci, a następnie przenosi ją z powrotem do pamięci zarządzanej PtrToStructure przy użyciu metody .

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

Poniższy przykład przedstawia sposób marshalingu niezarządzanego bloku pamięci do struktury zarządzanej PtrToStructure przy użyciu metody .

Ważne

Ten kod zakłada kompilację 32-bitową. Przed użyciem kompilatora 64-bitowego zastąp ciąg IntPtr.ToInt32 .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);
        }

Uwagi

PtrToStructure jest często konieczne w przypadku międzyoperacjności modelu COM i wywołania platformy, gdy parametry struktury są reprezentowane jako System.IntPtr wartość. Typ wartości można przekazać do tej metody przeciążenia. W takim przypadku zwrócony obiekt jest wystąpieniem boxed. ptr Jeśli parametr jest równy IntPtr.Zero, null zostanie zwrócony.

Zobacz też

• GetTypeAttr(IntPtr)

PtrToStructure<T>(IntPtr)

Źródło:

Marshal.cs

Marshaluje dane z niezarządzanego bloku pamięci do nowo przydzielonego obiektu zarządzanego typu określonego przez parametr typu ogólnego.

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

Parametry typu

T

Typ obiektu, do którego mają zostać skopiowane dane. Musi to być sformatowana klasa lub struktura.

Parametry

ptr

IntPtr

nativeint

Wskaźnik do niezarządzanego bloku pamięci.

Zwraca

T

Obiekt zarządzany zawierający dane, do których ptr wskazuje parametr.

Wyjątki

ArgumentException

Układ nie T jest sekwencyjny ani jawny.

MissingMethodException

Klasa określona przez T nie ma dostępnego konstruktora bez parametrów.

Uwagi

PtrToStructure<T>(IntPtr) jest często konieczne w przypadku międzyoperacjności modelu COM i wywołania platformy, gdy parametry struktury są reprezentowane jako System.IntPtr wartości. Typ wartości można przekazać do tego przeciążenia metody. ptr Jeśli parametr jest równy IntPtr.Zero i T jest typem odwołania, null jest zwracany. Jeśli ptr wartość jest równa IntPtr.Zero i T jest typem wartości, NullReferenceException jest zgłaszana wartość .

PtrToStructure<T>(IntPtr, T)

Źródło:

Marshal.cs

Marshaluje dane z niezarządzanego bloku pamięci do zarządzanego obiektu określonego typu.

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)

Parametry typu

T

Typ elementu structure. Musi to być sformatowana klasa.

Parametry

ptr

IntPtr

nativeint

Wskaźnik do niezarządzanego bloku pamięci.

structure

T

Obiekt, do którego mają zostać skopiowane dane.

Wyjątki

ArgumentException

Układ struktury nie jest sekwencyjny ani jawny.

Uwagi

PtrToStructure<T>(IntPtr, T) jest często konieczne w przypadku międzyoperacjności modelu COM i wywołania platformy, gdy parametry struktury są reprezentowane jako IntPtr wartości. Nie można użyć tego przeciążenia metody z typami wartości. ptr Jeśli parametr jest równy IntPtr.Zero i T jest typem odwołania, null jest zwracany. Jeśli ptr wartość jest równa IntPtr.Zero i T jest typem wartości, NullReferenceException jest zgłaszana wartość .