Marshal.PtrToStructure Método

Definição

Namespace:

System.Runtime.InteropServices

Assembly:

System.Runtime.InteropServices.dll

Realizar o marshaling de dados de um bloco de memória não gerenciado para um objeto gerenciado.

Sobrecargas

PtrToStructure(IntPtr, Object)	Realizar o marshaling de dados de um bloco de memória não gerenciado para um objeto gerenciado.
PtrToStructure(IntPtr, Type)	Realiza marshal de dados de um bloco não gerenciado de memória para um objeto gerenciado recém-alocado do tipo especificado.
PtrToStructure<T>(IntPtr)	Realiza marshaling de dados de um bloco não gerenciado de memória para um objeto gerenciado recém-alocado do tipo especificado por um parâmetro de tipo genérico.
PtrToStructure<T>(IntPtr, T)	Realiza marshaling de dados de um bloco não gerenciado de memória para um objeto gerenciado do tipo especificado.

PtrToStructure(IntPtr, Object)

Origem:

Marshal.cs

Realizar o marshaling de dados de um bloco de memória não gerenciado para um objeto gerenciado.

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)

Parâmetros

ptr

IntPtr

nativeint

Um ponteiro para um bloco não gerenciado de memória.

structure

Object

O objeto para o qual os dados serão copiados. Isso deve ser uma instância de uma classe formatada.

Exceções

ArgumentException

O layout da estrutura não é sequencial nem explícito.

- ou -

Estrutura é um tipo de valor demarcado.

Comentários

PtrToStructure geralmente é necessário na interoperabilidade COM e na invocação de plataforma quando os parâmetros de estrutura são representados como um System.IntPtr valor. Você não pode usar esse método de sobrecarga com tipos de valor. Se o parâmetro for igual IntPtr.Zeroa ptr , null será retornado.

PtrToStructure(IntPtr, Type)

Origem:

Marshal.cs

Realiza marshal de dados de um bloco não gerenciado de memória para um objeto gerenciado recém-alocado do tipo especificado.

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

Parâmetros

ptr

IntPtr

nativeint

Um ponteiro para um bloco não gerenciado de memória.

structureType

Type

O tipo de objeto a ser criado. Esse objeto deve representar uma classe ou estrutura formatada.

Retornos

Object

Um objeto gerenciado que contém os dados apontados pelo parâmetro ptr.

Exceções

ArgumentException

O layout do parâmetro structureType não é sequencial ou explícito.

- ou -

O parâmetro structureType é uma definição de tipo genérico.

ArgumentNullException

structureType é null.

MissingMethodException

A classe especificada por structureType não tem um construtor sem parâmetros acessível.

Exemplos

O exemplo a seguir cria uma estrutura gerenciada, transfere-a para memória não gerenciada e, em seguida, transfere-a de volta para a memória gerenciada usando o PtrToStructure método .

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

O exemplo a seguir demonstra como realizar marshaling de um bloco de memória não gerenciado para uma estrutura gerenciada usando o PtrToStructure método .

Importante

Esse código pressupõe compilação de 32 bits. Antes de usar um compilador de 64 bits, substitua por 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);
        }

Comentários

PtrToStructure geralmente é necessário na interoperabilidade COM e na invocação de plataforma quando os parâmetros de estrutura são representados como um System.IntPtr valor. Você pode passar um tipo de valor para esse método de sobrecarga. Nesse caso, o objeto retornado é uma instância em caixa. Se o parâmetro for igual IntPtr.Zeroa ptr , null será retornado.

Confira também

• GetTypeAttr(IntPtr)

PtrToStructure<T>(IntPtr)

Origem:

Marshal.cs

Realiza marshaling de dados de um bloco não gerenciado de memória para um objeto gerenciado recém-alocado do tipo especificado por um parâmetro de tipo genérico.

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

Parâmetros de tipo

T

O tipo do objeto para o qual os dados serão copiados. Isso deve ser uma classe formatada ou uma estrutura.

Parâmetros

ptr

IntPtr

nativeint

Um ponteiro para um bloco não gerenciado de memória.

Retornos

T

Um objeto gerenciado que contém os dados que o parâmetro ptr aponta.

Exceções

ArgumentException

O layout do T não é sequencial nem explícito.

MissingMethodException

A classe especificada por T não tem um construtor sem parâmetros acessível.

Comentários

PtrToStructure<T>(IntPtr) geralmente é necessário na interoperabilidade COM e na invocação de plataforma quando os parâmetros de estrutura são representados como System.IntPtr valores. Você pode passar um tipo de valor para essa sobrecarga de método. Se o ptr parâmetro for igual IntPtr.Zero a e T for um tipo de referência, null será retornado. Se ptr for igual IntPtr.Zero a e T for um tipo de valor, um NullReferenceException será gerado.

PtrToStructure<T>(IntPtr, T)

Origem:

Marshal.cs

Realiza marshaling de dados de um bloco não gerenciado de memória para um objeto gerenciado do tipo especificado.

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)

Parâmetros de tipo

T

O tipo de structure. Isso deve ser uma classe formatada.

Parâmetros

ptr

IntPtr

nativeint

Um ponteiro para um bloco não gerenciado de memória.

structure

T

O objeto para o qual os dados serão copiados.

Exceções

ArgumentException

O layout da estrutura não é sequencial nem explícito.

Comentários

PtrToStructure<T>(IntPtr, T) geralmente é necessário na interoperabilidade COM e na invocação de plataforma quando os parâmetros de estrutura são representados como IntPtr valores. Você não pode usar essa sobrecarga de método com tipos de valor. Se o ptr parâmetro for igual IntPtr.Zero a e T for um tipo de referência, null será retornado. Se ptr for igual IntPtr.Zero a e T for um tipo de valor, um NullReferenceException será gerado.