Udostępnij za pośrednictwem


Marshal.PtrToStructure Metoda

Definicja

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

Przeciążenia

PtrToStructure(IntPtr, Object)
Przestarzałe.

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

PtrToStructure(IntPtr, Type)
Przestarzałe.

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
Źródło:
Marshal.cs
Źródło:
Marshal.cs

Przestroga

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

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

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

Atrybuty

Wyjątki

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.

Dotyczy

PtrToStructure(IntPtr, Type)

Źródło:
Marshal.cs
Źródło:
Marshal.cs
Źródło:
Marshal.cs

Przestroga

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

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);
[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);
public static object? PtrToStructure (IntPtr ptr, Type structureType);
[System.Security.SecurityCritical]
public static object PtrToStructure (IntPtr ptr, Type structureType);
public static object PtrToStructure (IntPtr ptr, Type structureType);
[System.Runtime.InteropServices.ComVisible(true)]
public static object PtrToStructure (IntPtr ptr, Type structureType);
[System.Security.SecurityCritical]
[System.Runtime.InteropServices.ComVisible(true)]
public static object PtrToStructure (IntPtr ptr, Type structureType);
[<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>]
static member PtrToStructure : nativeint * Type -> obj
static member PtrToStructure : nativeint * Type -> obj
[<System.Security.SecurityCritical>]
static member PtrToStructure : nativeint * Type -> obj
[<System.Runtime.InteropServices.ComVisible(true)>]
static member PtrToStructure : nativeint * Type -> obj
[<System.Security.SecurityCritical>]
[<System.Runtime.InteropServices.ComVisible(true)>]
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

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

Atrybuty

Wyjątki

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

-lub-

Parametr structureType jest definicją typu ogólnego.

structureType to null.

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ż

Dotyczy

PtrToStructure<T>(IntPtr)

Źródło:
Marshal.cs
Źródło:
Marshal.cs
Ź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);
[System.Security.SecurityCritical]
public static T PtrToStructure<T> (IntPtr ptr);
public static T? PtrToStructure<T> (IntPtr ptr);
public static T PtrToStructure<T> (IntPtr ptr);
[<System.Security.SecurityCritical>]
static member PtrToStructure : nativeint -> 'T
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.

Atrybuty

Wyjątki

Układ nie T jest sekwencyjny ani jawny.

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ść .

Dotyczy

PtrToStructure<T>(IntPtr, T)

Źródło:
Marshal.cs
Źródło:
Marshal.cs
Ź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);
[System.Security.SecurityCritical]
public static void PtrToStructure<T> (IntPtr ptr, T structure);
public static void PtrToStructure<T> (IntPtr ptr, T structure);
[<System.Security.SecurityCritical>]
static member PtrToStructure : nativeint * 'T -> unit
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.

Atrybuty

Wyjątki

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ść .

Dotyczy