用 Roslyn 做個 JIT 的 AOP

victor.x.qu發表於2020-12-15
ROS

0. 前言

上接：AOP有幾種實現方式

接下來說說怎麼做AOP的demo，先用csharp 說下動態編織和靜態編織，有時間再說點java的對應內容。

第一篇先說Roslyn 怎麼做個JIT的AOP demo。

為啥這樣講呢？

實際是因為Roslyn 已經包含了JIT的全部部分，那我也就不用說任何JIT的實現了。（真爽）

所以本篇實際說的是以下這些內容：

怎麼引入Roslyn做JIT編譯程式碼

代理模式的AOP是什麼樣

為什麼不推薦在生產環境不做優化就這樣玩？

1. JIT編譯程式碼

Roslyn 是.NET的編譯器，感興趣的可以參見文件 https://docs.microsoft.com/en-us/dotnet/csharp/roslyn-sdk/

實際上Roslyn已經做的非常簡單了，幾行程式碼引入進來就可以編譯csharp程式碼了。

不信我們就手把手寫一個

1.1 引入Roslyn包

 <ItemGroup>
    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.6.0" />
    <PackageReference Include="System.Runtime.Loader" Version="4.3.0" />
  </ItemGroup>

1.2 程式碼轉化為語法樹

public SyntaxTree ParseToSyntaxTree(string code)
{
  var parseOptions = new CSharpParseOptions(LanguageVersion.Latest, preprocessorSymbols: new[] { "RELEASE" });
  // 有許多其他配置項，最簡單這些就可以了
  return CSharpSyntaxTree.ParseText(code, parseOptions);
}

1.3 準備編譯器例項

public CSharpCompilation BuildCompilation(SyntaxTree syntaxTree)
{
  var compilationOptions = new CSharpCompilationOptions(
    concurrentBuild: true,
    metadataImportOptions: MetadataImportOptions.All,
    outputKind: OutputKind.DynamicallyLinkedLibrary,
    optimizationLevel: OptimizationLevel.Release,
    allowUnsafe: true,
    platform: Platform.AnyCpu,
    checkOverflow: false,
    assemblyIdentityComparer: DesktopAssemblyIdentityComparer.Default);
  // 有許多其他配置項，最簡單這些就可以了
  var references = AppDomain.CurrentDomain.GetAssemblies()
    .Where(i => !i.IsDynamic && !string.IsNullOrWhiteSpace(i.Location))
    .Distinct()
    .Select(i => MetadataReference.CreateFromFile(i.Location));
  // 獲取編譯時所需用到的dll， 這裡我們直接簡單一點 copy 當前執行環境的
  return CSharpCompilation.Create("code.cs", new SyntaxTree[] { syntaxTree }, references, compilationOptions);
}

1.4 編譯到記憶體中

public Assembly ComplieToAssembly(CSharpCompilation compilation)
{
    using (var stream = new MemoryStream())
    {
        var restult = compilation.Emit(stream);
        if (restult.Success)
        {
            stream.Seek(0, SeekOrigin.Begin);
            return AssemblyLoadContext.Default.LoadFromStream(stream);
        }
        else
        {
            throw new Exception(restult.Diagnostics.Select(i => i.ToString()).DefaultIfEmpty().Aggregate((i, j) => i + j));
        }
    }
}

1.5 測試一下

static void TestJIT()
{
     var code = @"
    public class HiJ
    {
        public void Test(string v)
        {
            System.Console.WriteLine($""Hi, {v}!"");
        }
    }";
    var jit = new Jit();
    var syntaxTree = jit.ParseToSyntaxTree(code);
    var compilation = jit.BuildCompilation(syntaxTree);
    var assembly = jit.ComplieToAssembly(compilation);
    // test
    foreach (var item in assembly.GetTypes())
    {
        Console.WriteLine(item.FullName);
        item.GetMethod("Test").Invoke(Activator.CreateInstance(item), new object[] { "joker" });
    }
}

執行結果：

HiJ

Hi, joker!

就這麼簡單，你就可以JIT了，想幹什麼都可以了。

2. 用代理方式實現AOP

2.1 回顧代理是什麼

這裡單獨再說一下代理是什麼，

畢竟很多AOP框架或者其他框架都有利用代理的思想，

為什麼都要這樣玩呢？

很簡單，代理就是幫你做相同事情，並且可以比你做的更多，還一點兒都不動到你原來的程式碼。

比如如下 真實的class 和代理class 看起來一模一樣

但兩者的真實的程式碼可能是這樣子的

RealClass:

public class RealClass
{
  public virtual int Add(int i, int j)
  {
    return i + j;
  }
}


ProxyClass:

public class ProxyClass : RealClass
{
    public override int Add(int i, int j)
    {
        int r = 0;
        i += 7;
        j -= 7;
        r = base.Add(i, j);
        r += 55;
        return r;
    }
}

所以我們呼叫的時候會是這樣

2.2 做一個Proxy程式碼生成器

那麼我們來做一個上面例子中能生成一模一樣的ProxyClass 程式碼生成器

首先，我們都知道 csharp 再執行中可以反射獲取後設資料（反編譯出程式碼也可以做，就是我們殺雞用牛刀呢？）

我們知道了後設資料，就可以拼字串拼出我們想要的程式碼（對，你沒看錯，我們拼字串就夠了）

廢話不說， show you code

public class ProxyGenerator
{
    public string GenerateProxyCode(Type type, Action<StringBuilder, MethodBase> beforeCall, Action<StringBuilder, MethodBase> afterCall)
    {
        var sb = new StringBuilder();
        sb.Append($"{(type.IsPublic ? "public" : "")} class {type.Name}Proxy : {type.Name} {{ ");
        foreach (var method in type.GetTypeInfo().DeclaredMethods)
        {
            GenerateProxyMethod(beforeCall, afterCall, sb, method);
        }
        sb.Append(" }");
        return sb.ToString();
    }
    private static void GenerateProxyMethod(Action<StringBuilder, MethodBase> beforeCall, Action<StringBuilder, MethodBase> afterCall, StringBuilder sb, MethodInfo method)
    {
        var ps = method.GetParameters().Select(p => $"{p.ParameterType.FullName} {p.Name}");
        sb.Append($"{(method.IsPublic ? "public" : "")} override {method.ReturnType.FullName} {method.Name}({string.Join(",", ps)}) {{");
        sb.Append($"{method.ReturnType.FullName} r = default;");
        beforeCall(sb, method);
        sb.Append($"r = base.{method.Name}({string.Join(",", method.GetParameters().Select(p => p.Name))});");
        afterCall(sb, method);
        sb.Append("return r; }");
    }
}

測試一下

public static class TestProxyGenerator
{
    public static void Test()
    {
        var generator = new ProxyGenerator();
        var code = generator.GenerateProxyCode(typeof(RealClass), (sb, method) => { }, (sb, method) => { sb.Append("r++;"); });
        Console.WriteLine(code);
    }
}

結果：

public class RealClassProxy : RealClass { public override System.Int32 Add(System.Int32 i,System.Int32 j) {System.Int32 r = default;r = base.Add(i,j);r++;return r; } }

2.3 結合在一起測試一下

public static class TestProxyJit
{
    public static RealClass GenerateRealClassProxy()
    {
        var generator = new ProxyGenerator();
        var code = generator.GenerateProxyCode(typeof(RealClass), (sb, method) => { }, (sb, method) => { sb.Append("r++;"); });
        var jit = new Jit();
        var syntaxTree = jit.ParseToSyntaxTree(code);
        var compilation = jit.BuildCompilation(syntaxTree);
        var assembly = jit.ComplieToAssembly(compilation);
        return Activator.CreateInstance(assembly.GetTypes().First()) as RealClass;
    }
    public static void Test()
    {
        RealClass proxy = GenerateRealClassProxy();
        var i = 5;
        var j = 10;
        Console.WriteLine($"{i} + {j} = {(i + j)}, but proxy is {proxy.Add(i, j)}");
    }
}

結果為：

5 + 10 = 15, but proxy is 16

是的，我們寫了這麼多程式碼就是為了讓 15 變成 16 ，讓別人不知道 多了個 r++; ，這就是AOP的意義

完整的demo 放在 https://github.com/fs7744/AopDemoList

2.4 再完善完善就可以了。。。（也就再寫個幾年）

你只需要完善如下：

  • 支援 void 方法
  • 支援 async await 方法
  • 支援抽象類
  • 支援介面
  • 支援構造方法
  • 支援屬性
  • 支援索引器
  • 支援 in out ref
  • 支援泛型
  • 支援巢狀類
  • 支援剩下的各種各樣情況

嗯，相信你自己，你可以的

3. 不推薦在生產環境不經過優化就這樣玩，為什麼？

3.1 兩幅圖

手寫的proxy ：

jit 編譯proxy：

隨著需要編譯的Proxy class 增多， cpu 和 記憶體都會一樣增多
所以要使用呢，最好用一些優化過的方案，情況會好的多，比如 https://github.com/dotnetcore/Natasha

3.2 你信不信得過呼叫你api的對方

嗯，這是一個信任度的問題，所以不要呼叫 Roslyn sdk 的輸入暴露不做校驗，黑客的騷操作是大家永遠想不完的

只要對方可信，Roslyn sdk api 別人是不會呼叫的哦

但是我們都知道前人們都告訴我們有個準則：不要相信任何Input。

所以大家的貓主子會不會跟著別人跑掉就看大家信心和手段了。

相關文章