C# Roslyn 编译器Api妙用：动态生成类并实现接口

在上一篇文章中有讲到使用反射手写IL代码动态生成类并实现接口。

反射的妙用：C#通过反射动态生成类型继承接口并实现

有位网友推荐使用

Roslyn

去脚本化动态生成，今天这篇文章就主要讲怎么使用

Roslyn

动态生成类。

###什么是Roslyn

最初

C#

语言的编译器是用

C++

编写的，后来微软推出了一个新的用

C#

自身编写的编译器：

Roslyn

，它属于自举编译器。

所谓自举编译器就是指，某种编程语言的编译器就是用该语言自身来编写的。自举编译器的每个版本都是用该版本之前的版本来编译的，但它的第一个版本必须由其它语言编写的编译器来编译，比如

Roslyn

的第一个版本是由

C++

编写的编译器来编译的。很多编程语言发展成熟后都会用该语言本身来编写自己的编译器，比如

C#

和

Go

语言。

在

.NET

平台，

Roslyn

编译器负责将

C#

和

VB

代码编译为程序集。

大多数现有的传统编译器都是“黑盒”模式，它们将源代码转换成可执行文件或库文件，中间发生了什么我们无法知道。与之不同的是，Roslyn 允许你通过 API 访问代码编译过程中的每个阶段。

以上内容取自：精致码农 • 王亮

###Roslyn实现拦截器 拦截器用过

MVC

的应该都很熟悉：

Filter

，比如，请求拦截器：

OnActionExecuting

、

OnActionExecuted

。

下面就用

Roslyn

简单实现类似：

OnActionExecuting

的拦截效果。

#####1、先准备一段拦截脚本

const string before = "public static string before(string name)" +
"{" +
"Console.WriteLine($\"{name}已被拦截，形成检测成功，无感染风险。\");" +
"return name+\"：健康\";" +
"}";

#####2、准备传参对象

public class ParameterVector
{
public string arg1 { get; set; }
}

#####3、编写脚本执行代码

/// <summary>
/// 执行Before脚本
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public static string ExecuteBeforeScript(string name)
{
StringBuilder builder = new StringBuilder();
builder.Append("public class intercept");
builder.Append("{");
builder.Append(before);
builder.Append("}");
builder.Append("return intercept.before(arg1);");
var result = CS.CSharpScript.RunAsync<string>(builder.ToString(),
// 引用命名空间
ScriptOptions.Default.AddReferences("System.Linq").AddImports("System"),
// 参数对象
globals: new ParameterVector() { arg1 = name },
globalsType: typeof(ParameterVector))
.Result;
return result.ReturnValue;
}

#####4、调用拦截器

static void Main(string[] args)
{
var msg = Console.ReadLine();
travel(msg);
Console.WriteLine("执行完毕...");
}

static string travel(string userName)
{
var result = Script.ExecuteBeforeScript(userName);
Console.WriteLine(result);
return result;
}

咋一看上面的逻辑其实很傻，就是将方法逻辑写成静态脚本去动态调用。还不如直接就在方法内部写相关逻辑。

但是我们将思维发散一下，将静态脚本替换为从文件读取，在业务上线后，我们只需要修改文件脚本的逻辑即可，是不是觉得用处就来了，是不是有那么点

AOP

的感觉了。

###Roslyn动态实现接口 下面的内容与之前反射动态生成的结果一样，只是换了一种方法去处理。

#####1、准备需要实现的接口，老User了

public interface IUser
{
string getName(string name);
}

#####2、准备一个拦截类

public class Intercept
{
public static void Before(string name)
{
Console.WriteLine($"拦截成功，参数：{name}");
}
}

#####3、根据接口生成一个静态脚本

/// <summary>
/// 生成静态脚本
/// </summary>
/// <typeparam name="Tinteface"></typeparam>
/// <returns></returns>
public static string GeneratorScript<Tinteface>(string typeName)
{
var t = typeof(Tinteface);
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("using System;");
stringBuilder.Append($"using {t.Namespace};");
stringBuilder.Append($"namespace {typeName}_namespace");
stringBuilder.Append("{");
stringBuilder.Append($"public class {typeName}:{t.Name}");
stringBuilder.Append(" {");
MethodInfo[] targetMethods = t.GetMethods();
foreach (MethodInfo targetMethod in targetMethods)
{
if (targetMethod.IsPublic)
{
var returnType = targetMethod.ReturnType;
var parameters = targetMethod.GetParameters();
string pStr = string.Empty;
List<string> parametersName = new List<string>();
foreach (ParameterInfo parameterInfo in parameters)
{
var pType = parameterInfo.ParameterType;
pStr += $"{pType.Name} _{pType.Name},";
parametersName.Add($"_{pType.Name}");
}

stringBuilder.Append($"public {returnType.Name} {targetMethod.Name}({pStr.TrimEnd(',')})");
stringBuilder.Append(" {");
foreach (var pName in parametersName)
{
stringBuilder.Append($"Intercept.Before({pName});");
}
stringBuilder.Append($"return \"执行成功。\";");
stringBuilder.Append(" }");
}
}
stringBuilder.Append(" }");
stringBuilder.Append(" }");
return stringBuilder.ToString();
}

#####4、构建程序集

/// <summary>
/// 构建类对象
/// </summary>
/// <typeparam name="Tinteface"></typeparam>
/// <returns></returns>
public static Type BuildType<Tinteface>()
{
var typeName = "_" + typeof(Tinteface).Name;
var text = GeneratorTypeCode<Tinteface>(typeName);

// 将代码解析成语法树
SyntaxTree tree = SyntaxFactory.ParseSyntaxTree(text);

var objRefe = MetadataReference.CreateFromFile(typeof(Object).Assembly.Location);
var consoleRefe = MetadataReference.CreateFromFile(typeof(IUser).Assembly.Location);

var compilation = CSharpCompilation.Create(
syntaxTrees: new[] { tree },
assemblyName: $"assembly{typeName}.dll",
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary),
references: AppDomain.CurrentDomain.GetAssemblies().Select(x => MetadataReference.CreateFromFile(x.Location)));

Assembly compiledAssembly;
using (var stream = new MemoryStream())
{
// 检测脚本代码是否有误
var compileResult = compilation.Emit(stream);compiledAssembly = Assembly.Load(stream.GetBuffer());
}
return compiledAssembly.GetTypes().FirstOrDefault(c => c.Name == typeName);
}

#####5、调用动态生成类的方法

static void Main(string[] args)
{
Type t = codeExtension.BuildType<IUser>();
var method = t.GetMethod("getName");
object obj = Activator.CreateInstance(t);
var result = method.Invoke(obj, new object[] { "张三" }).ToString();
Console.WriteLine(result);
}

两种（

Roslyn/IL

）动态生成方式比起来，从编码方式比起来差别还是挺大的。

手写IL无疑要比

Roslyn

复杂很多，手写

IL

无法调试，无法直观展示代码，没有错误提示，如果业务逻辑比较复杂将会是一场灾难。

Roslyn

将业务逻辑脚本化，代码通过脚本可直观展示，有明确的错误提示。

至于性能方面暂时还没有做比较，后续有机会再将两种方式的性能对比放出来。

###Roslyn异常提示

上面的代码中，有一小段代码：

// 检测脚本代码是否有误
var compileResult = compilation.Emit(stream);

脚本无误的返回值如下：

当脚本出现错误的返回值如下：

从上面的错误中很明显可以看到，缺少了

System

命名空间，以及方法签名与接口不匹配。

以上就是

Roslyn

编译器

Api

的一些简单的使用。

无绪分享