Закрепить обновляемую структуру перед переходом к неуправляемому коду?

Является ли небезопасный код вариантом?

// allocate unmanaged memory
Foo* foo = (Foo*)Marshal.AllocHGlobal(sizeof(Foo));

// initialize struct
foo->bar = 0;

// invoke unmanaged function which remembers foo
UnsafeNativeMethods.Bar(foo);
Console.WriteLine(foo->bar);

// update struct
foo->bar = 10;

// invoke unmanaged function which uses remembered foo
UnsafeNativeMethods.Qux();
Console.WriteLine(foo->bar);

// free unmanaged memory
Marshal.FreeHGlobal((IntPtr)foo);

Это компилируется и не генерирует исключение, но у меня нет под рукой неуправляемой функции, чтобы проверить, работает ли она.

Из MSDN:

Когда AllocHGlobal вызывает LocalAlloc, он передает флаг LMEM_FIXED, который блокирует выделенную память. Кроме того, выделенная память не заполняется нулями.

Использование закрепленной памяти в этом случае не является хорошей идеей, учитывая, что память для структуры должна быть действительной в течение длительного времени. GCHandle.Alloc() упакует структуру и сохранит ее в куче. Когда он будет закреплен, он будет долговременным бременем для сборщика мусора, поскольку ему нужно постоянно находить способ обойти камень на дороге.

Простое решение — выделить память для структуры в неуправляемой памяти. Используйте Marshal.SizeOf() для получения размера структуры и Marshal.AllocCoTaskMem() для выделения памяти. Это даст вам указатель, который нужно передать неуправляемому коду. Инициализируйте память с помощью Marshal.StructureToPtr(). И читать обновления структуры, написанные неуправляемым кодом, с помощью PtrToStructure().

Если вы делаете это часто, вы будете постоянно копировать структуру. Это может быть дорого, в зависимости от размера конструкции. Чтобы избежать этого, используйте небезопасный указатель для прямого доступа к неуправляемой памяти. Некоторый базовый синтаксис:

using System;
using System.Runtime.InteropServices;

class Program {
  unsafe static void Main(string[] args) {
    int len = Marshal.SizeOf(typeof(Test));
    IntPtr mem = Marshal.AllocCoTaskMem(len);
    Test* ptr = (Test*)mem;
    ptr->member1 = 42;
    // call method
    //..
    int value = ptr->member1;
    Marshal.FreeCoTaskMem(mem);
  }
  public struct Test {
    public int member1;
  }
}

Вместо закрепления вам нужно использовать Marshal. StructureToPtr и Marshal.PtrToStructure, чтобы маршалировать структуру в память, которую можно использовать в машинном коде.

Пример структуры:

[StructLayout(LayoutKind.Sequential)]
public struct OVERLAPPED_STRUCT
{
   public IntPtr InternalLow;
   public IntPtr InternalHigh;
   public Int32 OffsetLow;
   public Int32 OffsetHigh;
   public IntPtr EventHandle;
}

Как прикрепить его к структуре и использовать:

OVERLAPPED_STRUCT over_lapped = new OVERLAPPED_STRUCT();
// edit struct in managed code
over_lapped.OffsetLow = 100;
IntPtr pinned_overlap_struct = Marshal.AllocHGlobal(Marshal.SizeOf(over_lapped));
Marshal.StructureToPtr(over_lapped, pinned_overlap_struct, true);

// Pass pinned_overlap_struct to your unmanaged code
// pinned_overlap_struct changes ...

// Get resulting new struct
OVERLAPPED_STRUCT nat_ov = (OVERLAPPED_STRUCT)Marshal.PtrToStructure(pinned_overlap_struct, typeof(OVERLAPPED_STRUCT));
// See what new value is
int offset_low = nat_ov.OffsetLow;
// Clean up
Marshal.FreeHGlobal(pinned_overlap_struct);

Как насчет того, чтобы структура включала интерфейс ActOnMe() и метод, например:

delegate void ActByRef<T1,T2>(ref T1 p1, ref T2 p2);
interface IActOnMe<TT> {ActOnMe<T>(ActByRef<TT,T> proc, ref T param);}
struct SuperThing : IActOnMe<SuperThing>
{
  int this;
  int that;
  ...
  void ActOnMe<T>(ActByRef<SuperThing,T>, ref T param)
  {
    proc(ref this, ref param);
  }
}

Поскольку делегат принимает универсальный параметр по ссылке, в большинстве случаев можно избежать накладных расходов на создание замыканий путем передачи делегата статическому методу вместе со ссылкой на структуру для переноса данных в этот метод или из него. Кроме того, приведение уже упакованного экземпляра SuperThing к IActOnMe<SuperThing> и вызов ActOnMe<T> для него предоставит поля этого упакованного экземпляра для обновления, в отличие от создания другой их копии, как это произошло бы с приведением типа к структура.

Чтобы ответить на ваше редактирование:

Просто подумал... есть ли способ закрепить родительский объект, содержащий структуру, а затем получить указатель на struct, а не на объект-контейнер?

Я так думаю. Во всяком случае, вы должны иметь возможность использовать управляемый массив структур (возможно, массив из одной).

Вот пример кода:

    [StructLayout(LayoutKind.Sequential)]
    struct SomeStructure
    {
        public int first;
        public int second;
        public SomeStructure(int first, int second) { this.first=first; this.second=second; }
    }
    
    /// <summary>
    /// For this question on Stack Overflow:
    /// https://stackoverflow.com/questions/1850488/pinning-an-updateble-struct-before-passing-to-unmanaged-code
    /// </summary>
    private static void TestModifiableStructure()
    {
        SomeStructure[] objArray = new SomeStructure[1];
        objArray[0] = new SomeStructure(10, 10);
        
        GCHandle hPinned = GCHandle.Alloc(objArray, GCHandleType.Pinned);

        //Modify the pinned structure, just to show we can
        objArray[0].second = 42;

        Console.WriteLine("Before unmanaged incrementing: {0}", objArray[0].second);
        PlaceholderForUnmanagedFunction(hPinned.AddrOfPinnedObject());
        Console.WriteLine("Before unmanaged incrementing: {0}", objArray[0].second);
        
        //Cleanup
        hPinned.Free();
    }
    
    //Simulates an unmanaged function that accesses ptr->second
    private static void PlaceholderForUnmanagedFunction(IntPtr ptr)
    {
        int secondInteger = Marshal.ReadInt32(ptr, 4);
        secondInteger++;
        Marshal.WriteInt32(ptr, 4, secondInteger);
    }

И его вывод:

Before unmanaged incrementing: 42
Before unmanaged incrementing: 43