用 Roslyn 做个 JIT 的 AOP

用户头像
八苦-瞿昙
关注
发布于: 2020 年 07 月 14 日
用Roslyn做个JIT的AOP

-0.1 系列目录

  1. 无价值人生记录.0

  2. AOP 有几种实现方式?

  3. 用 Roslyn 做个 JIT 的 AOP

  4. 基于 Source Generators 做个 AOP 静态编织小实验

  5. 思想无语言边界:以 cglib 介绍 AOP 在 java 的一个实现方式

  6. 常见的emit实现AOP demo



0. 前言

副标题:无价值人生记录.0:浪费 1000% 时间去做一个用来节省 1% 时间的“轮子玩具”(下:AOP实践1 JIT)

上接:AOP有几种实现方式 https://xie.infoq.cn/article/6f65df715a020c0b77f4cd266

接下来说说怎么做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 再完善完善就可以了。。。(也就再写个几年)

你只需要完善如下:

  1. 支持 void 方法

  2. 支持 async await 方法

  3. 支持抽象类

  4. 支持接口

  5. 支持构造方法

  6. 支持属性

  7. 支持索引器

  8. 支持 in out ref

  9. 支持泛型

  10. 支持嵌套类

  11. 支持剩下的各种各样情况

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

3. 不推荐在生产环境这样玩,为什么?

3.1 两幅图

手写的proxy :



jit 编译proxy:

随着需要编译的Proxy class 增多, cpu 和 内存都会一样增多



3.2 你信不信得过调用你api的对方

嗯,这是一个信任度的问题,

只要对方可信,Roslyn sdk api 别人是不会调用的哦

但是我们都知道前人们都告诉我们有个准则:不要相信任何Input

所以大家的猫主子会不会跟着别人跑掉就看大家信心和手段了。

发布于: 2020 年 07 月 14 日 阅读数: 210
用户头像

八苦-瞿昙

关注

一个假和尚,不懂人情世故。 2018.11.23 加入

会点点技术,能写些代码,只爱静静。 g hub: https://github.com/fs7744 黑历史:https://www.cnblogs.com/fs7744

评论 (3 条评论)

发布
用户头像
挺好
2020 年 07 月 23 日 21:54
回复
用户头像
学习了!
2020 年 07 月 15 日 22:59
回复
用户头像
点赞再看
2020 年 07 月 15 日 09:26
回复
没有更多了
用Roslyn做个JIT的AOP