如何基于32/64位原生DLL构建AnyCPU程序集？求成熟方案

针对你遇到的DllImport编译常量无法动态切换32/64位入口点和调用约定的问题，以下是几个成熟高效的解决方案：

方案1：使用UnmanagedFunctionPointer动态绑定（推荐） #

通过运行时动态加载函数指针并绑定到对应委托，实现自动适配位数差异，无需编译时区分。

实现步骤： #

1. 定义匹配原生函数签名的委托类型，分别指定对应位数的调用约定：

   [UnmanagedFunctionPointer(CallingConvention.ThisCall)]
   private delegate ImPlotPoint ImPlotPointCtor_32();
   
   [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
   private delegate ImPlotPoint ImPlotPointCtor_64();
   

2. 导入系统API用于加载动态库和获取函数地址：

   [DllImport("kernel32.dll")]
   private static extern IntPtr LoadLibrary(string dllName);
   
   [DllImport("kernel32.dll")]
   private static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
   

3. 在静态构造函数中根据进程位数加载对应函数：

   private static readonly ImPlotPointCtor_32 _ctor32;
   private static readonly ImPlotPointCtor_64 _ctor64;
   
   static ImPlotNative()
   {
       IntPtr dllHandle = LoadLibrary("implot");
       if (IntPtr.Size == 4) // 32位进程
       {
           IntPtr funcPtr = GetProcAddress(dllHandle, "??0ImPlotPoint@@QAE@XZ");
           _ctor32 = Marshal.GetDelegateForFunctionPointer<ImPlotPointCtor_32>(funcPtr);
       }
       else // 64位进程
       {
           IntPtr funcPtr = GetProcAddress(dllHandle, "??0ImPlotPoint@@QEAA@XZ");
           _ctor64 = Marshal.GetDelegateForFunctionPointer<ImPlotPointCtor_64>(funcPtr);
       }
   }
   

4. 对外提供统一调用入口：

   public static ImPlotPoint CreateImPlotPoint()
   {
       return IntPtr.Size == 4 ? _ctor32() : _ctor64();
   }
   

优点：无需拆分程序集或维护多套导入代码，统一对外接口，运行时自动适配；可控性强，适合复杂绑定场景。
缺点：需要手动管理函数指针和委托，比静态DllImport多少量代码。

方案2：C++/CLI中间层 #

通过C++/CLI编写适配层，在中间层处理32/64位的编译差异，对外暴露统一托管接口。

实现步骤： #

1. 创建C++/CLI类库，利用编译宏区分位数：

   #ifdef _WIN32
   #define IMPLOT_CTOR_CALL __thiscall
   #define IMPLOT_CTOR_NAME "??0ImPlotPoint@@QAE@XZ"
   #else
   #define IMPLOT_CTOR_CALL __cdecl
   #define IMPLOT_CTOR_NAME "??0ImPlotPoint@@QEAA@XZ"
   #endif
   
   using namespace System;
   
   public ref class ImPlotWrapper
   {
   public:
       static ImPlotPoint^ CreateImPlotPoint()
       {
           typedef ImPlotPoint* (IMPLOT_CTOR_CALL* CtorFunc)();
           CtorFunc ctor = reinterpret_cast<CtorFunc>(GetProcAddress(GetModuleHandle(L"implot"), IMPLOT_CTOR_NAME));
           return gcnew ImPlotPoint(ctor());
       }
   };
   

2. 托管项目直接引用该C++/CLI类库，调用统一的CreateImPlotPoint方法即可。

优点：托管代码完全无需处理位数逻辑，中间层自动适配；适合大规模原生库绑定场景。
缺点：需掌握C++/CLI语法，额外维护一个中间层项目。

方案3：优化版双内部类+统一封装 #

针对你提到的双类方案做优化，仅在封装层做一次位数判断，避免业务代码重复检查。

实现步骤： #

1. 定义两个内部类分别对应32/64位导入：

   internal static class NativeMethods32
   {
       [DllImport("implot", EntryPoint = "??0ImPlotPoint@@QAE@XZ", CallingConvention = CallingConvention.ThisCall)]
       public static extern ImPlotPoint ImPlotPointCtor();
   }
   
   internal static class NativeMethods64
   {
       [DllImport("implot", EntryPoint = "??0ImPlotPoint@@QEAA@XZ", CallingConvention = CallingConvention.Cdecl)]
       public static extern ImPlotPoint ImPlotPointCtor();
   }
   

2. 封装对外统一调用类：

   public static class ImPlotNative
   {
       private static readonly bool _is32Bit = IntPtr.Size == 4;
   
       public static ImPlotPoint CreateImPlotPoint()
       {
           return _is32Bit ? NativeMethods32.ImPlotPointCtor() : NativeMethods64.ImPlotPointCtor();
       }
   }
   

优点：比原始双类方案简洁，仅在封装层做一次位数判断，业务代码调用统一接口。
缺点：仍需维护两套DllImport代码，但复杂度较低。

内容的提问来源于stack exchange，提问作者aybe