Marshal.PtrToStructure Metoda

Definice

Obor názvů:

System.Runtime.InteropServices

Sestavení:

System.Runtime.InteropServices.dll

Zařadí data z nespravovaného bloku paměti do spravovaného objektu.

Přetížení

PtrToStructure(IntPtr, Object)	Zařadí data z nespravovaného bloku paměti do spravovaného objektu.
PtrToStructure(IntPtr, Type)	Zařadí data z nespravovaného bloku paměti do nově přiděleného spravovaného objektu zadaného typu.
PtrToStructure<T>(IntPtr)	Zařadí data z nespravovaného bloku paměti do nově přiděleného spravovaného objektu typu typu určeného parametrem obecného typu.
PtrToStructure<T>(IntPtr, T)	Zařadí data z nespravovaného bloku paměti do spravovaného objektu zadaného typu.

PtrToStructure(IntPtr, Object)

Zdroj:

Marshal.cs

Zařadí data z nespravovaného bloku paměti do spravovaného objektu.

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

Ukazatel na nespravovaný blok paměti.

structure

Object

Objekt, do kterého mají být data zkopírována. Musí se jednat o instanci formátované třídy.

Výjimky

ArgumentException

Rozložení struktury není sekvenční ani explicitní.

-nebo-

Struktura je typ hodnoty v rámečku.

Poznámky

PtrToStructure je často nutné při volání zprostředkovatele komunikace com a platformy, pokud jsou parametry struktury reprezentovány jako System.IntPtr hodnota. Tuto metodu přetížení nelze použít s typy hodnot. Pokud se ptr parametr rovná IntPtr.Zero, null vrátí se .

PtrToStructure(IntPtr, Type)

Zdroj:

Marshal.cs

Zařadí data z nespravovaného bloku paměti do nově přiděleného spravovaného objektu zadaného 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

Ukazatel na nespravovaný blok paměti.

structureType

Type

Typ objektu, který má být vytvořen. Tento objekt musí představovat formátovanou třídu nebo strukturu.

Návraty

Object

Spravovaný objekt obsahující data, na která ptr ukazuje parametr .

Výjimky

ArgumentException

Rozložení structureType parametrů není sekvenční ani explicitní.

-nebo-

Parametr structureType je definice obecného typu.

ArgumentNullException

structureType je null.

MissingMethodException

Třída určená parametrem structureType nemá přístupný konstruktor bez parametrů.

Příklady

Následující příklad vytvoří spravovanou strukturu, přenese ji do nespravované paměti a pak ji pomocí metody přenese zpět do spravované paměti 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

Následující příklad ukazuje, jak zařašovat nespravovaný blok paměti do spravované struktury pomocí PtrToStructure metody .

Důležité

Tento kód předpokládá 32bitovou kompilaci. Před použitím 64bitového kompilátoru nahraďte za 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);
        }

Poznámky

PtrToStructure je často nutné při volání zprostředkovatele komunikace com a platformy, pokud jsou parametry struktury reprezentovány jako System.IntPtr hodnota. Této metodě přetížení můžete předat typ hodnoty. V tomto případě je vrácený objekt instancí v rámečku. Pokud se ptr parametr rovná IntPtr.Zero, null vrátí se .

Viz také

• GetTypeAttr(IntPtr)

PtrToStructure<T>(IntPtr)

Zdroj:

Marshal.cs

Zařadí data z nespravovaného bloku paměti do nově přiděleného spravovaného objektu typu typu určeného parametrem obecného typu.

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 objektu, do kterého mají být data zkopírována. Musí se jednat o formátovanou třídu nebo strukturu.

Parametry

ptr

IntPtr

nativeint

Ukazatel na nespravovaný blok paměti.

Návraty

T

Spravovaný objekt, který obsahuje data, na která ptr odkazuje parametr.

Výjimky

ArgumentException

Rozložení T není sekvenční ani explicitní.

MissingMethodException

Třída určená parametrem T nemá přístupný konstruktor bez parametrů.

Poznámky

PtrToStructure<T>(IntPtr) je často nutné při volání zprostředkovatele komunikace a platformy COM, pokud jsou parametry struktury reprezentovány jako System.IntPtr hodnoty. Do přetížení této metody můžete předat typ hodnoty. Pokud se ptr parametr rovná IntPtr.Zero a T je odkazovým typem, null vrátí se hodnota . Pokud ptr se IntPtr.Zero rovná a T je typ hodnoty, NullReferenceException vyvolá se hodnota .

PtrToStructure<T>(IntPtr, T)

Zdroj:

Marshal.cs

Zařadí data z nespravovaného bloku paměti do spravovaného objektu zadaného 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 .structure Musí se jednat o formátovanou třídu.

Parametry

ptr

IntPtr

nativeint

Ukazatel na nespravovaný blok paměti.

structure

T

Objekt, do kterého mají být data zkopírována.

Výjimky

ArgumentException

Rozložení struktury není sekvenční ani explicitní.

Poznámky

PtrToStructure<T>(IntPtr, T) je často nutné při volání zprostředkovatele komunikace a platformy COM, pokud jsou parametry struktury reprezentovány jako IntPtr hodnoty. U typů hodnot nelze použít přetížení této metody. Pokud se ptr parametr rovná IntPtr.Zero a T je odkazovým typem, null vrátí se hodnota . Pokud ptr se IntPtr.Zero rovná a T je typ hodnoty, NullReferenceException vyvolá se hodnota .