对于接下来冗长的介绍，我们深表歉意。我需要比我更了解 P/Invoke 内部结构的人的见解。

以下是我如何将包含函数指针的结构从 C 编码到 C#。我想知道这是否是最干净和/或最有效的方式。

我正在与一个用 C 编码的 native DLL 交互，它提供以下入口点:

void* getInterface(int id);

您必须传递 getInterface(int) 以下枚举值之一:

enum INTERFACES
{
  FOO,
  BAR
};

它返回一个指向包含函数指针的结构的指针，例如:

typedef struct IFOO
{
  void (*method1)(void* self, int a, float b);
  void (*method2)(void* self, int a, float b, int c);
} IFoo;

下面是如何在 C 中使用它:

IFoo* interface = (IFoo*)getInterface(FOO);
interface->method1(obj, 0, 1.0f); // where obj is an instance of an object
                                  // implementing the IFoo interface.

在 C# 中，我有一个 Library 类，它使用 P/Invoke 映射 getInterface(int) 入口点。

class Library
{
  [DllImport("MyDLL"), EntryPoint="getInterface", CallingConvention=CallingConvention.Cdecl)]
  public static extern IntPtr GetInterface(int id);
};

然后我定义:

struct IFoo
{
  public M1 method1;
  public M2 method2;


  [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  public delegate void M1(IntPtr self, int a, float b);

  [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  public delegate void M2(IntPtr self, int a, float b, int c);
}

我是这样使用它的:

IntPtr address = Library.GetInterface((int)Interfaces.FOO);
IFoo i = (IFoo)Marshal.PtrToStructure(address, typeof(IFoo));

i.method1(obj, 0, 1.0f): // where obj is an instance of an object
                         // implementing the IFoo interface.

我有以下问题:

1. 映射整个结构是否比使用 Marshal.GetDelegateForFunctionPointer() 映射结构内部的单个指针效率低？

   因为我基本上不需要接口(interface)公开的所有方法，所以我可以这样做(经过测试和工作):

   unsafe
   {
     IntPtr address = Library.GetInterface(id);
     IntPtr m2address = new IntPtr(((void**)address.toPointer())[1]);
   
     M2 method2 = (M2)Marshal.GetDelegateForFunctionPointer(m2address, typeof(M2));
   
     method2(obj, 0, 1.0f, 1);
   }
   

2. 当使用 Marshal.PtrToStructure() 一次映射整个结构时，有没有比我描述的更简洁的方法？我的意思是比必须为每个方法等定义委托(delegate)类型更简洁？

编辑:为了清楚和完整起见，在上面的代码片段中，obj 是使用 void* createObject(int type) 入口点获得的实例。

EDIT2:方法 1) 的一个优点是 Marshal.GetDelegateForFunctionPointer() 仅从 .NET Framework 2.0 开始可用。但是，Marshal.PrtToStructure() 始终可用。也就是说，我不确定现在是否值得确保 1.0 的兼容性。

EDIT3:我尝试使用 Reflector 检查生成的代码但它并没有提供太多信息，因为所有有趣的细节都是在辅助函数中完成的，例如 PtrToStructureHelper 并且没有公开。然后，即使我可以看到框架内部做了什么，运行时也有机会优化掉一些东西，我不知 Prop 体是什么、为什么以及什么时候:)

但是，我对问题中描述的两种方法进行了基准测试。与 Marshal.GetDelegateForFunctionPointer() 方法相比，Marshal.PtrToStructure() 方法慢了大约 10%；一个包含所有不感兴趣的函数的 IntPtr 的结构。

我还将 Marshal.GetDelegateForFunctionPointer() 与我自己的滚动编码器进行了比较:我对齐表示调用堆栈的 struct，将其固定在内存中，将其地址传递给我使用在 asm 中编码的蹦床的 native 端，以便调用函数使用内存区域作为其参数堆栈(这是可能的，因为 cdecl x86 调用约定传递堆栈上的所有函数参数) .时间是等效的。

最佳答案

这是我要开始的。

用法:

IFoo foo = UnsafeNativeMethods.GetFooInterface();
foo.Method1(0, 1.0f);

实现:

internal interface IFoo
{
    void Method1(int a, float b);
    void Method2(int a, float b, int c);
}

internal static class UnsafeNativeMethods
{
    public static IFoo GetFooInterface()
    {
        IntPtr self = GetInterface(InterfaceType.Foo);
        NativeFoo nativeFoo = (NativeFoo)Marshal.PtrToStructure(self, typeof(NativeFoo));
        return new NativeFooWrapper(self, nativeFoo.Method1, nativeFoo.Method2);
    }

    [DllImport("mydll.dll", EntryPoint = "getInterface", CallingConvention = CallingConvention.Cdecl)]
    private static extern IntPtr GetInterface(InterfaceType id);

    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    private delegate void Method1Delegate(IntPtr self, int a, float b);

    [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    private delegate void Method2Delegate(IntPtr self, int a, float b, int c);

    private enum InterfaceType
    {
        Foo,
        Bar
    }

    private struct NativeFoo
    {
        public Method1Delegate Method1;
        public Method2Delegate Method2;
    }

    private sealed class NativeFooWrapper : IFoo
    {
        private IntPtr _self;
        private Method1Delegate _method1;
        private Method2Delegate _method2;

        public NativeFooWrapper(IntPtr self, Method1Delegate method1, Method2Delegate method2)
        {
            this._self = self;
            this._method1 = method1;
            this._method2 = method2;
        }

        public void Method1(int a, float b)
        {
            _method1(_self, a, b);
        }

        public void Method2(int a, float b, int c)
        {
            _method2(_self, a, b, c);
        }
    }
}

关于C# P/调用 : Marshalling structures containing function pointers，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/1969049/