.NET静态代码织入——肉夹馍（Rougamo）发布3.0

来源：cnblogs　　作者：nigture　　时间：2024/5/6 16:17:44　　对本文有异议

肉夹馍(https://github.com/inversionhourglass/Rougamo)通过静态代码织入方式实现AOP的组件，其主要特点是在编译时完成AOP代码织入，相比动态代理可以减少应用启动的初始化时间让服务更快可用，同时还能对静态方法进行AOP操作。

正文

虽又是一个大版本，但本次大版本没有重大的功能上线，主要是修改了代码织入方式，这样的改动牵扯到一些现有功能。

代码织入方式变化

在3.0之前的版本中采用的是代码内嵌的方式进行织入，下面用简化代码进行演示：

// 原始方法
public void M()
{
    Console.WriteLine(1);
    Console.WriteLine(2);
    Console.WriteLine(3);
}
// 3.0版本之前织入代码后
public void M()
{
    var context = new MethodContext(...);
    var mo = new AbcAttribute();
    mo.OnEntry(context);
    try
    {
        Console.WriteLine(1);
        Console.WriteLine(2);
        Console.WriteLine(3);
        mo.OnSuccess(context);
    }
    catch (Exception e)
    {
        context.Exception = e;
        mo.OnException(context);
        throw;
    }
    finally
    {
        mo.OnExit(context);
    }
}

在3.0版本中采用的是代理调用的方式进行代码织入，将原方法拷贝为一个新方法$Rougamo_M，然后修改原方法进行代码织入后调用$Rougamo_M，简化代码如下：

// 将原方法M拷贝为$Rougamo_M
public void $Rougamo_M()
{
    Console.WriteLine(1);
    Console.WriteLine(2);
    Console.WriteLine(3);
}
// 修改原方法进行代码织入并调用拷贝后的原方法
public void M()
{
    var context = new MethodContext(...);
    var mo = new AbcAttribute();
    mo.OnEntry(context);
    try
    {
        $Rougamo_M();
        mo.OnSuccess(context);
    }
    catch (Exception e)
    {
        context.Exception = e;
        mo.OnException(context);
        throw;
    }
    finally
    {
        mo.OnExit(context);
    }
}

不同织入方法带来的影响

ExMoAttribute的弃用

早在1.2版本中新增了ExMoAttribute，可能很多朋友对此都并不了解，ExMoAttribute主要用来屏蔽使用和不使用async/await语法所带来的差异，因为使用async/await语法后，在编译时会生成对应的状态机类型，那么肉夹馍就会对应修改状态机代码进行织入，而不使用async/await语法的方法就只能对原方法进行代码织入，下面用代码简单演示其中的差异：

public async Task Delay()
{
    Console.WriteLine(1);
    await Task.Delay(2000);
    Console.WriteLine(2);
}
// 使用async/await语法调用Delay
public async Task WithSyntax()
{
    var context = new MethodContext(...);
    var mo = new AbcAttribute();
    mo.OnEntry(context);
    try
    {
        await Delay();
        mo.OnSuccess(context);
    }
    catch (Exception e)
    {
        context.Exception = e;
        mo.OnException(context);
        throw;
    }
    finally
    {
        mo.OnExit(context);
    }
}
// 不使用async/await语法调用Delay
public Task WithoutSyntax()
{
    var context = new MethodContext(...);
    var mo = new AbcAttribute();
    mo.OnEntry(context);
    try
    {
        var task = Delay();
        mo.OnSuccess(context);
        return task;
    }
    catch (Exception e)
    {
        context.Exception = e;
        mo.OnException(context);
        throw;
    }
    finally
    {
        mo.OnExit(context);
    }
}

在上面的代码示例中，没有使用async/await的WithoutSyntax方法会在Delay还没有执行完毕之前就执行OnSuccess和OnExit方法。

ExMoAttribute针对没有使用async/await语法的方法通过在OnSuccess方法中使用ContinueWith达到在异步方法实际执行完毕后执行OnExit系列方法。ExMoAttribute虽然能够解决语法差异带来的问题，但也增加了一定的复杂性，同时因为其可能鲜为人知，所以在使用时因语法差异带来的问题可能后知后觉。

在3.0版本中由于使用代理调用的方式，被代理方法是否使用async/await语法是被屏蔽的，代理方只需要知道你的返回值是Task即可，所以在3.0版本中MoAttribute即可应对是否使用async/await语法的两种情况，ExMoAttribute在3.0版本中标记为Obsolete并将在4.0版本中直接删除。下面用代码简单说明3.0对于是否使用async/await语法的统一处理方式：

// 拷贝WithSyntax原方法为$Rougamo_WithSyntax
public async Task $Rougamo_WithSyntax()
{
    await Delay();
}
// 拷贝WithoutSyntax原方法为$Rougamo_WithoutSyntax
public Task $Rougamo_WithoutSyntax()
{
    return Delay();
}
public async Task WithSyntax()
{
    // ...代码织入
    try
    {
        await $Rougamo_WithSyntax();
    }
    catch
    {
        // ...代码织入
    }
}
public async Task WithoutSyntax()
{
    // ...代码织入
    try
    {
        await $Rougamo_WithoutSyntax();
    }
    catch
    {
        // ...代码织入
    }
}

async void 弱支持

如果说前面介绍的是织入方式改变带来的优势，那么这里介绍的就是劣势了。async void方法是一种特殊的异步方法，同样会生成对应的状态机类型，但调用该方法无法进行await操作，也就无法等待该方法实际执行完毕。在3.0版本之前，由于采取的是内嵌代码织入，直接修改状态机代码完成织入，所以OnExit系列方法可以在正确的时间点执行，而在3.0版本后由于采用了代理调用的方式，所以在执行OnExit系列方法时无法确保方法实际已经执行完毕。

关于async void的织入方式目前还在思考中，考虑到winform和wpf中可能存在不少的async void写法，代理调用的织入方式可能就无法满足目前的使用要求了，所以我将在github中发布一个issue进行投票统计，请日常开发涉及到async void的朋友移步到github（ https://github.com/inversionhourglass/Rougamo/issues/68 ）中进行投票，投票将在4.0版本开发末期截止。

支持步入调试

在3.0版本之前，应用了肉夹馍完成织入的方法在开发时无法进行步入调试，这是因为之前的版本没有对调试信息做对应的修改，没有去做这一功能也是因为比较复杂懒得整。在3.0修改代码织入方式后，修改对应的调试信息相对要简单许多，因此3.0版本支持步入调试

仅ref/out支持刷新参数

在2.1版本中新增刷新参数功能，支持在OnSuccess / OnException / OnExit中通过MethodContext.Arguments获取最新的参数值，但在3.0版本之后，由于织入代码方式的改变，此功能仅支持ref和out参数。

public void M(int x, out decimal y, ref string z)
{
    // ...
}
// 3.0 版本之前的织入方式
public void M(int x, out decimal y, ref string z)
{
    try
    {
        // ...
        // 由于是内嵌织入，在这里可以直接获取到所有最新的参数值，所以参数x也可以更新
        context.Arguments[0] = x;
        context.Arguments[1] = y;
        context.Arguments[2] = z;
        mo.OnSuccess(context);
    }
    catch (Exception e)
    {
        // ...
        // 由于是内嵌织入，在这里可以直接获取到所有最新的参数值，所以参数x也可以更新
        context.Arguments[0] = x;
        context.Arguments[1] = y;
        context.Arguments[2] = z;
        mo.OnException(context);
        throw;
    }
}
// 3.0 版本的织入方式
public void M(int x, out decimal y, ref string z)
{
    try
    {
        $Rougamo_M(x, out y, ref z);
        // 由于是代理调用织入，参数x在$Rougamo_M中被重新赋值后无法在外部获取，所以仅更新参数y和z
        context.Arguments[1] = y;
        context.Arguments[2] = z;
        mo.OnSuccess(context);
    }
    catch (Exception e)
    {
        // ...
    }
}

构造方法织入方式不变

由于构造方法较为特殊，readonly字段仅可在构造方法中初始化，所以无法使用代理调用的织入方式，这也表示使用肉夹馍代码织入的构造方法无法支持步入调试。

织入方式切换

新的编织方式涉及众多代码，代码织入部分的代码近乎重写，虽然做了大量的测试，但为了保证稳定性提供了降级配置，修改项目中FodyWeavers.xml文件中Rougamo节点配置，通过设置proxy-calling="false"，将织入方式改回3.0版本之前的内嵌织入方式。需要注意的是，该配置仅为过渡配置，将在4.0版本中移出并最终仅保留代理织入的方式，如果代理织入的方式存在任何问题，请及时反馈。

<Weavers xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="FodyWeavers.xsd">
  <Rougamo proxy-calling="false" />
</Weavers>