11

我使用一些旧的 API，需要将结构的指针传递给异步运行的非托管代码。

换句话说，在我将结构指针传递给非托管代码后，非托管代码复制指针并立即返回。非托管代码可以在后台，在另一个线程中访问该结构。我无法控制在另一个线程中运行的非托管代码，也无法控制线程本身。

固定的 { } 语句不能用于固定，因为它不是为异步非托管固定而设计的。

GCHandle 只能固定引用，因此必须将结构装箱才能使用 GCHandle。我试过了，它有效。它的主要问题是您无法从托管代码更新结构。要更新一个结构，首先我们需要将它拆箱，然后更新，然后再装箱，但是……哎呀……又装箱了？！？这意味着内存中的前一个指针仍然指向旧的非最新结构，而新结构有另一个指针，这意味着我需要将新指针传递给非托管代码......不适用于我的案子。

如何在没有固定 {} 语句的情况下将结构固定在内存中，以便我可以从托管代码更新它而不更改它的指针？

谢谢。

编辑：

只是想...有没有办法固定包含结构的父对象，然后获取结构的指针而不是容器对象？

4

6 回答 6

7

在这种情况下使用固定内存不是一个好主意，因为结构的内存需要长时间有效。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;
  }
}
于 2009-12-05T01:06:43.777 回答
5

不安全代码是一种选择吗？

// 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 标志，这会导致分配的内存被锁定到位。此外，分配的内存不是零填充的。

于 2009-12-05T00:39:49.880 回答
1

您需要使用Marshal.StructureToPtr和Marshal.PtrToStructure将结构编组到可在本机代码中使用的内存中，而不是固定。

于 2009-12-05T00:15:55.827 回答
0

结构示例：

[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);
于 2009-12-05T00:26:44.823 回答
0

ActOnMe()让结构包含一个接口和方法怎么样：

委托 void ActByRef<T1,T2>(ref T1 p1, ref T2 p2);
接口 IActOnMe<TT> {ActOnMe<T>(ActByRef<TT,T> proc, ref T param);}
结构 SuperThing : IActOnMe<SuperThing>
{
  诠释这个；
  诠释那个；
  ...
  void ActOnMe<T>(ActByRef<SuperThing,T>, ref T 参数)
  {
    过程（参考这个，参考参数）；
  }
}

因为委托通过引用获取泛型参数，所以在大多数情况下，通过将委托传递给静态方法以及对结构的引用以将数据传入或传出该方法，应该可以避免创建闭包的开销。此外，强制转换一个已装箱的SuperThingto实例IActOnMe<SuperThing>并调用ActOnMe<T>它会公开该装箱实例的字段以进行更新，而不是创建它们的另一个副本，就像对结构进行类型转换时那样。

于 2012-03-06T19:05:46.650 回答
0

要回答您的编辑：

只是想...有没有办法固定包含结构的父对象，然后获取结构的指针而不是容器对象？

我认同。如果有的话，您应该能够使用托管的结构数组（可能是一个数组）。

这是一个示例代码：

    [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
于 2020-08-14T15:42:49.907 回答