C#中无需反射，实现父类方法在子类任意方法前后执行的方案咨询

嘿，这个问题挺实际的！先直接给你结论：如果是你代码里这种静态方法的场景，不借助反射的话，很难做到「自动在子类任意静态方法前后调用父类静态方法」——因为C#里静态成员是绑定到具体类的，没有实例方法那种继承多态的机制，也没法像实例方法那样轻松做切面逻辑。

不过我们可以分情况来聊，看看有没有符合你需求的替代方案：

一、如果可以改成实例方法：有多种优雅方案 #

如果你的场景允许把静态方法改成实例方法，那可选的方案就很多了，而且都不用反射：

1. 模板方法模式（最经典的实现） #

父类定义固定的执行流程，子类只需要实现具体的业务逻辑，前置和后置逻辑由父类统一控制：

public abstract class Base
{
    protected void ThisWillBeCalledBeforeAnyMethodInChild()
    {
        Console.WriteLine("执行子类方法前的前置逻辑");
    }
    
    protected void ThisWillBeCalledAFTERAnyMethodInChild()
    {
        Console.WriteLine("执行子类方法后的后置逻辑");
    }

    // 父类定义公共执行入口
    public void Execute()
    {
        ThisWillBeCalledBeforeAnyMethodInChild();
        DoBusinessLogic();
        ThisWillBeCalledAFTERAnyMethodInChild();
    }

    // 子类必须实现的业务逻辑方法
    protected abstract void DoBusinessLogic();
}

public class SomeClass : Base
{
    protected override void DoBusinessLogic()
    {
        Console.WriteLine("执行SomeClass的业务逻辑");
    }
}

调用时直接实例化子类调用Execute()即可，完全不用操心前后逻辑的调用。

2. 编译时AOP织入（比如PostSharp） #

如果你需要支持多个不同的方法，而不是统一的Execute入口，可以用编译时AOP工具（比如PostSharp）。它会在编译阶段把前置/后置逻辑直接织入到目标方法的IL代码里，运行时完全不需要反射：

// 定义一个自定义特性，标记需要织入前后逻辑的方法
public class BaseMethodAspect : OnMethodBoundaryAspect
{
    public override void OnEntry(MethodExecutionArgs args)
    {
        Console.WriteLine("方法执行前的逻辑");
    }

    public override void OnExit(MethodExecutionArgs args)
    {
        Console.WriteLine("方法执行后的逻辑");
    }
}

public class Base { }

public class SomeClass : Base
{
    [BaseMethodAspect]
    public void SomeMethod1()
    {
        Console.WriteLine("执行SomeMethod1");
    }

    [BaseMethodAspect]
    public void SomeMethod2()
    {
        Console.WriteLine("执行SomeMethod2");
    }
}

这种方式可以给任意实例方法添加前后逻辑，而且完全是编译时处理，性能和原生代码一样。

二、必须用静态方法的场景：只能做半自动化实现 #

如果必须保留静态方法，那由于C#静态成员的特性限制，没法做到完全自动调用，但可以通过父类提供包装方法，强制子类调用，实现半自动化：

public class Base
{
    protected static void WrapStaticAction(Action action)
    {
        ThisWillBeCalledBeforeAnyMethodInChild();
        action();
        ThisWillBeCalledAFTERAnyMethodInChild();
    }
    
    protected static void ThisWillBeCalledBeforeAnyMethodInChild()
    {
        Console.WriteLine("静态方法前置逻辑");
    }
    
    protected static void ThisWillBeCalledAFTERAnyMethodInChild()
    {
        Console.WriteLine("静态方法后置逻辑");
    }
}

public class SomeClass : Base
{
    public static void SomeMethod1()
    {
        // 子类方法内部调用父类的包装方法，把自己的逻辑传进去
        WrapStaticAction(() =>
        {
            Console.WriteLine("执行SomeMethod1的静态逻辑");
        });
    }
    
    public static void SomeMethod2()
    {
        WrapStaticAction(() =>
        {
            Console.WriteLine("执行SomeMethod2的静态逻辑");
        });
    }
}

这个方案的好处是不用反射，而且前后逻辑只需要在父类写一次，子类只需要调用包装方法即可。缺点是需要子类主动配合，没法完全“自动”触发——毕竟静态方法没有运行时的拦截点。

为什么静态方法没法完全自动实现？ #

简单说下原因：C#的静态方法是编译时绑定的，没有实例方法那种运行时动态分派的机制；而且静态成员不能被继承重写，父类无法感知子类的静态方法调用，自然没法自动插入前后逻辑。

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