c# - C# IL 在调用 C++ DLL 时如何通过 Ref 取回参数

Question

C# 程序需要调用 dll，但看起来参数输出与输入的值相同。所以我制作了这个简短的示例来测试。 这是 C++ Dll 代码: .h

#define EtrpDll extern "C" __declspec(dllexport)
EtrpDll void __fastcall WhyWrong(int &m);

.cpp

#include"Header.h"
#include<iostream>
void __fastcall WhyWrong(int &m) {
    m++;
}

int main() {
    int m = 0;
    WhyWrong(m);
    std::cout << m;
    int y;
    std::cin >> y;
}

C# 代码: .cs

using System;

using System.Runtime.InteropServices;
using System.Reflection;
using System.Reflection.Emit;

namespace DllTest
{
    class Class1 {
        [DllImport("Kernel32.dll")]
        private static extern IntPtr LoadLibrary(string lpFileName);
        [DllImport("Kernel32.dll")]
        private static extern bool FreeLibrary(IntPtr hModule);
        [DllImport("Kernel32.dll")]
        private static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);
        [DllImport("Kernel32.dll")]
        private static extern int GetLastError();
        private static IntPtr hModule = IntPtr.Zero;
        private static AssemblyName GbsAssemblyName;
        private static AssemblyBuilder GbsAssemblyBuilder;
        private static ModuleBuilder GbsModuleBuilder;
        public enum ModePass {
            ByValue = 0x0001,
            ByRef = 0x0002
        }

        private IntPtr GFuncPtr = IntPtr.Zero;
        private Type[] GParaType;
        private ILGenerator GIL;
        private ModePass[] GMdPass;
        public object[] GObject;
        private string Mname;

        private static Type GReturn = typeof(void);




        static void Main() {
            Class1.DllIni();
            Class1 G_WhyW = new Class1(new Type[1] { typeof(int) }, new Class1.ModePass[1] { Class1.ModePass.ByRef }, new object[1] { (int)0 });
            G_WhyW.LoadFunc("WhyWrong");
            Class1.GCreateGlbFunc();
            G_WhyW.GObject[0] = (int)1;//Input
            G_WhyW.InvokeDllFunc();
            Console.WriteLine((int)G_WhyW.GObject[0]);
            Console.ReadLine();
            Class1.UnLoadDll();
        }


        public static void DllIni(){
            hModule = LoadLibrary("DllTest.dll");
            if (hModule == IntPtr.Zero) {
                Console.WriteLine("DLL Not Loaded");
                int e = GetLastError();
                Console.WriteLine("Error Code: " + e);
            }
            GbsAssemblyName = new AssemblyName();
            GbsAssemblyName.Name = "GbsCore";
            GbsAssemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(GbsAssemblyName, AssemblyBuilderAccess.Run);
            GbsModuleBuilder = GbsAssemblyBuilder.DefineDynamicModule("FuncGrp");
        }
        public static void GCreateGlbFunc() {
            GbsModuleBuilder.CreateGlobalFunctions();
        }
        public void LoadFunc(string lpProcName) {
            GFuncPtr = GetProcAddress(hModule, lpProcName);
            if (GFuncPtr == IntPtr.Zero) {
                Console.WriteLine("Function " + lpProcName + " Not Loaded");
            }
            Mname = lpProcName + "_T";
            MethodBuilder GbsMethodBuilder = GbsModuleBuilder.DefineGlobalMethod(Mname, MethodAttributes.Public | MethodAttributes.Static, GReturn, GParaType);
            GIL = GbsMethodBuilder.GetILGenerator();
            if (GObject != null) {
                for (int i = 0; i < GObject.Length; i++) {
                    switch (GMdPass[i]) {
                        case ModePass.ByValue:
                            GIL.Emit(OpCodes.Ldarg, i);
                            break;
                        case ModePass.ByRef:
                            GIL.Emit(OpCodes.Ldarga, i);
                            break;
                        default:
                            Console.WriteLine("Pass Mode Error");
                            break;
                    }
                }
            }
            if (IntPtr.Size == 4) { GIL.Emit(OpCodes.Ldc_I4, GFuncPtr.ToInt32()); } //Platform
            else if (IntPtr.Size == 8) { GIL.Emit(OpCodes.Ldc_I8, GFuncPtr.ToInt64()); }
            else { throw new PlatformNotSupportedException(); }
            GIL.EmitCalli(OpCodes.Calli, CallingConvention.FastCall, GReturn, GParaType);
            GIL.Emit(OpCodes.Ret);
        }
        public void InvokeDllFunc() {
            MethodInfo GbsMethodInfo;
            if (GParaType == null) {
                GbsMethodInfo = GbsModuleBuilder.GetMethod(Mname);
            }
            else {
                GbsMethodInfo = GbsModuleBuilder.GetMethod(Mname, GParaType);
            }
            GbsMethodInfo.Invoke(null, GObject);//return void
        }
        public static void UnLoadDll() {
            FreeLibrary(hModule);
            hModule = IntPtr.Zero;
        }

        public Class1(Type[] T, ModePass[] MP, object[] OB) {
            GParaType = T;
            GMdPass = MP;
            GObject = OB;
        }
    }
}

在调用函数WhyWrong之前，参数的值为1，但是我尝试得到的结果也是1。应该是 2，不是吗？

Answer 1

这个动态方法的签名是 void(int)，而不是你想要的 void(ref int)，因为它是用 new Type[ ]{typeof(int)}.

支持使用反射调用带有引用参数的方法(并修改参数数组)，因此完全摆脱 ModePass 枚举并使用 typeof(int).MakeByRefType() 定义方法时。

整个 switch (GMdPass[i]) 是不必要的。由于参数是通过引用传递的，因此它将作为引用本身简单地提供给被调用函数(ldarg 就足够了)。

顺便说一下，你为什么不直接使用 Marshal.GetDelegateForFunctionPointer ？它几乎与动态方法一样，但应该更快。您只需要定义一个委托(delegate)类型(非泛型)。

此外，FastCall 是否不受支持？