.NET 4.8 WinForms实现所有方法自动调用指定调试方法的方案

完全可以通过反射+Reflection.Emit在运行时实现需求，无需依赖第三方库。核心思路是在程序启动时，动态生成目标方法的包装逻辑——先调用你的调试日志方法，再执行原方法代码，最后用动态生成的逻辑替换原方法的实现。属性的getter/setter本质是特殊命名的方法，所以可以和普通方法一起处理。

实现步骤与代码示例 #

1. 定义调试日志方法 #

先实现一个用于打印调试信息的工具方法，接收方法名和参数数组：

using System;
using System.Linq;
using System.Diagnostics;

public static class DebugLogger
{
    public static void LogMethodCall(string fullMethodName, object[] parameters)
    {
        var paramDetails = parameters.Length == 0 
            ? "无参数" 
            : string.Join(", ", parameters.Select(p => p?.ToString() ?? "null"));
        Debug.WriteLine($"[{DateTime.Now:HH:mm:ss}] 调用: {fullMethodName} | 参数: {paramDetails}");
    }
}

2. 实现运行时注入逻辑 #

通过反射遍历目标程序集的类型和方法，用Reflection.Emit生成包装方法，再通过内部API MethodRental.ReplaceMethod 替换原方法的实现：

using System;
using System.Reflection;
using System.Reflection.Emit;
using System.Linq;

public static class MethodInjector
{
    public static void InjectDebugLogging(Assembly targetAssembly)
    {
        // 获取.NET内部的MethodRental类及其ReplaceMethod方法（用于替换方法体）
        var methodRentalType = typeof(object).Assembly.GetType("System.Reflection.MethodRental");
        var replaceMethod = methodRentalType.GetMethod(
            "ReplaceMethod", 
            BindingFlags.Public | BindingFlags.Static);

        foreach (var type in targetAssembly.GetTypes())
        {
            // 过滤不需要处理的类型：抽象类、泛型定义类等
            if (type.IsAbstract || type.IsSealed && type.IsGenericTypeDefinition)
                continue;

            // 遍历当前类的所有实例方法（含私有、属性方法）
            foreach (var method in type.GetMethods(
                BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly))
            {
                // 过滤构造函数、抽象方法、未密封的虚方法（避免干扰系统逻辑）
                if (method.IsConstructor || method.IsAbstract || (method.IsVirtual && !method.IsFinal))
                    continue;

                // 处理普通方法和属性的get/set方法
                InjectWrapper(method, replaceMethod);
            }
        }
    }

    private static void InjectWrapper(MethodInfo originalMethod, MethodInfo replaceMethod)
    {
        // 创建动态方法，签名与原方法一致
        var paramTypes = originalMethod.GetParameters().Select(p => p.ParameterType).ToArray();
        var dynamicMethod = new DynamicMethod(
            $"Wrapped_{originalMethod.Name}",
            originalMethod.ReturnType,
            paramTypes,
            originalMethod.DeclaringType,
            true);

        var il = dynamicMethod.GetILGenerator();

        // --------------------------
        // 第一步：调用DebugLogger.LogMethodCall
        // --------------------------
        // 加载第一个参数：完整方法名（类名+方法名）
        il.Emit(OpCodes.Ldstr, $"{originalMethod.DeclaringType.FullName}.{originalMethod.Name}");
        // 加载第二个参数：参数数组
        var paramCount = paramTypes.Length;
        il.Emit(OpCodes.Ldc_I4, paramCount);
        il.Emit(OpCodes.Newarr, typeof(object));
        // 逐个将参数装箱后存入数组
        for (int i = 0; i < paramCount; i++)
        {
            il.Emit(OpCodes.Dup);
            il.Emit(OpCodes.Ldc_I4, i);
            il.Emit(OpCodes.Ldarg, i);
            var paramType = originalMethod.GetParameters()[i].ParameterType;
            if (paramType.IsValueType)
                il.Emit(OpCodes.Box, paramType); // 值类型需要装箱
            il.Emit(OpCodes.Stelem_Ref);
        }
        // 调用日志方法
        il.Emit(OpCodes.Call, typeof(DebugLogger).GetMethod("LogMethodCall"));

        // --------------------------
        // 第二步：执行原方法逻辑
        // --------------------------
        // 加载实例对象（非静态方法需要）
        if (!originalMethod.IsStatic)
            il.Emit(OpCodes.Ldarg_0);
        // 加载所有参数
        for (int i = 0; i < paramCount; i++)
        {
            il.Emit(OpCodes.Ldarg, originalMethod.IsStatic ? i : i + 1);
        }
        // 调用原方法
        il.Emit(originalMethod.IsVirtual ? OpCodes.Callvirt : OpCodes.Call, originalMethod);

        // --------------------------
        // 第三步：返回结果（如果有返回值）
        // --------------------------
        il.Emit(OpCodes.Ret);

        // 替换原方法的实现
        replaceMethod.Invoke(
            null, 
            new object[] { originalMethod.MethodHandle, dynamicMethod.MethodHandle, 0 });
    }
}

3. 在程序启动时启用注入 #

只在调试模式下执行注入，避免影响生产环境，在Program.cs的Main方法中添加调用：

using System;
using System.Windows.Forms;
using System.Reflection;

static class Program
{
    [STAThread]
    static void Main()
    {
#if DEBUG
        // 对当前程序集的所有符合条件的方法注入日志逻辑
        MethodInjector.InjectDebugLogging(Assembly.GetExecutingAssembly());
#endif

        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new Form1());
    }
}

关键注意事项 #

• 仅调试模式启用：用#if DEBUG包裹注入逻辑，确保生产环境不会执行这段代码。
• 方法过滤规则：示例中过滤了构造函数、抽象方法、未密封的虚方法，你可以根据需求调整过滤条件，比如只处理特定命名空间下的类。
• 内部API依赖：MethodRental是.NET内部API，在.NET 4.8中稳定可用，但跨版本可能存在兼容性风险。
• 值类型参数处理：值类型参数需要装箱后才能存入object[]，示例中已经处理了这种情况。
• 性能影响：运行时注入会增加程序启动时间，仅适合开发调试阶段使用。

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