Roslyn 是微软为 C# 设计的一套分析器，它具有很强的扩展性。以至于我们只需要编写很少量的代码便能够编译并执行我们的代码。
作为 Roslyn 入门篇文章之一，你将可以通过本文学习如何开始编写一个 Roslyn 扩展项目 —— 编译一个类，然后执行其中的一段代码。
本文是 Roslyn 入门系列之一：
- Roslyn 入门：使用 Visual Studio 的语法可视化（Syntax Visualizer）窗格查看和了解代码的语法树
- Roslyn 入门：使用 .NET Core 版本的 Roslyn 编译并执行跨平台的静态的源码（本文）
- Roslyn 入门：使用 Roslyn 静态分析现有项目中的代码
我们希望做什么？
是否有过在编译期间修改一段代码的想法呢？
我曾经在 生成代码，从 T 到 T1, T2, Tn —— 自动生成多个类型的泛型 一文中提到过这样的想法，在这篇文章中，我希望只编写泛型的一个参数的版本 Demo<T>，然后自动生成 2~16 个参数的版本 Demo<T1, T2>, Demo<T1, T2, T3> … Demo<T1, T2, ... T16>。不过，在那篇文章中，我写了一个应用程序来完成这样的事情。我在另一篇文章 如何创建一个基于命令行工具的跨平台的 NuGet 工具包 中说到我们可以将这样的应用程序打包成一个 NuGet 工具包。也就是说，利用这两种不同的技术，我们可以制作一个在编译期间生成多个泛型的 NuGet 工具包。
不过，这样的生成方式不够通用。今天我们想生成泛型，明天我们想生成多语言类，后天我们又想生成代理类。能否做一种通用的方式来完成这样的任务呢？
于是，我想到可以使用 Roslyn。在项目中编写一段转换代码，我们使用通用的方式去编译和执行这段代码，以便完成各种各样日益增加的类型转换需求。具体来说，就是 使用 Roslyn 编译一段代码，然后执行它。
准备工作
与之前在 Roslyn 入门：使用 Roslyn 静态分析现有项目中的代码 中的不同，我们这次无需打开解决方案或者项目，而是直接寻找并编译源代码文件。所以（利好消息），我们这回可以使用 .NET Core 跨平台版本的 Roslyn 了。所以为了充分有跨平台特性，我们创建控制台应用 (.NET Core)。
▲ 千万不要吐槽相比于上一个入门教程来说，这次的界面变成了英文
安装必要的 NuGet 包
这次不需要完整的 .NET Framework 环境，也不需要打开解决方案和项目这种重型 API，所以一个简单的 NuGet 包足矣：
准备一份用于编译和执行代码文件
我直接使用 生成代码，从 T 到 T1, T2, Tn —— 自动生成多个类型的泛型 这篇文章中的例子。把其中最关键的文件拿来用于编译和生成试验。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
using System.Linq;
using static System.Environment;
namespace Walterlv.Demo.Roslyn
{
public class GenericGenerator
{
private static readonly string GeneratedAttribute =
@"[System.CodeDom.Compiler.GeneratedCode(""walterlv"", ""1.0"")]";
public string Transform(string originalCode, int genericCount)
{
if (genericCount == 1)
{
return originalCode;
}
var content = originalCode
// 替换泛型。
.Replace("<out T>", FromTemplate("<{0}>", "out T{n}", ", ", genericCount))
.Replace("Task<T>", FromTemplate("Task<({0})>", "T{n}", ", ", genericCount))
.Replace("Func<T, Task>", FromTemplate("Func<{0}, Task>", "T{n}", ", ", genericCount))
.Replace(" T, Task>", FromTemplate(" {0}, Task>", "T{n}", ", ", genericCount))
.Replace("(T, bool", FromTemplate("({0}, bool", "T{n}", ", ", genericCount))
.Replace("var (t, ", FromTemplate("var ({0}, ", "t{n}", ", ", genericCount))
.Replace(", t)", FromTemplate(", {0})", "t{n}", ", ", genericCount))
.Replace("return (t, ", FromTemplate("return ({0}, ", "t{n}", ", ", genericCount))
.Replace("<T>", FromTemplate("<{0}>", "T{n}", ", ", genericCount))
.Replace("(T value)", FromTemplate("(({0}) value)", "T{n}", ", ", genericCount))
.Replace("(T t)", FromTemplate("({0})", "T{n} t{n}", ", ", genericCount))
.Replace("(t)", FromTemplate("({0})", "t{n}", ", ", genericCount))
.Replace("var t =", FromTemplate("var ({0}) =", "t{n}", ", ", genericCount))
.Replace(" T ", FromTemplate(" ({0}) ", "T{n}", ", ", genericCount))
.Replace(" t;", FromTemplate(" ({0});", "t{n}", ", ", genericCount))
// 生成 [GeneratedCode]。
.Replace(" public interface ", $" {GeneratedAttribute}{NewLine} public interface ")
.Replace(" public class ", $" {GeneratedAttribute}{NewLine} public class ")
.Replace(" public sealed class ", $" {GeneratedAttribute}{NewLine} public sealed class ");
return content.Trim();
}
private static string FromTemplate(string template, string part, string separator, int count)
{
return string.Format(template,
string.Join(separator, Enumerable.Range(1, count).Select(x => part.Replace("{n}", x.ToString()))));
}
}
}
这份代码你甚至可以直接复制到你的项目中，一定是可以编译通过的。
编译这份代码
使用 Roslyn 编译一份代码是非常轻松愉快的。写出以下这三行就够了：
1
2
3
4
var syntaxTree = CSharpSyntaxTree.ParseText("那份代码的全文内容");
var compilation = CSharpCompilation.Create("assemblyname", new[] { syntaxTree },
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
var result = compilation.Emit(ms);
好吧，其实我是开玩笑的，这三行代码确实能够跑通过，不过得到的 result 是编译不通过的结局。为了能够在多数情况下编译通过，我写了更多的代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
using System;
using System.IO;
using System.Linq;
using System.Reflection;
using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
namespace Walterlv.Demo.Roslyn
{
class Program
{
static void Main(string[] args)
{
// 大家都知道在代码中写死文件路径是不对的，不过，我们这里是试验。放心，我会改的！
var file = @"D:\Development\Demo\Walterlv.Demo.Roslyn\Walterlv.Demo.Roslyn.Tests\GenericGenerator.cs";
var originalText = File.ReadAllText(file);
var syntaxTree = CSharpSyntaxTree.ParseText(originalText);
var type = CompileType("GenericGenerator", syntaxTree);
// 于是我们得到了编译后的类型，但是还不知道怎么办。
}
private static Type CompileType(string originalClassName, SyntaxTree syntaxTree)
{
// 指定编译选项。
var assemblyName = $"{originalClassName}.g";
var compilation = CSharpCompilation.Create(assemblyName, new[] { syntaxTree },
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
.AddReferences(
// 这算是偷懒了吗？我把 .NET Core 运行时用到的那些引用都加入到引用了。
// 加入引用是必要的，不然连 object 类型都是没有的，肯定编译不通过。
AppDomain.CurrentDomain.GetAssemblies().Select(x => MetadataReference.CreateFromFile(x.Location)));
// 编译到内存流中。
using (var ms = new MemoryStream())
{
var result = compilation.Emit(ms);
if (result.Success)
{
ms.Seek(0, SeekOrigin.Begin);
var assembly = Assembly.Load(ms.ToArray());
return assembly.GetTypes().First(x => x.Name == originalClassName);
}
throw new CompilingException(result.Diagnostics);
}
}
}
}
执行编译后的代码
既然得到了类型，那么执行这份代码其实毫无压力，因为我们都懂得反射（好吧，我假装你懂反射）。
1
2
3
var transformer = Activator.CreateInstance(type);
var newContent = (string) type.GetMethod("Transform").Invoke(transformer,
new object[] { "某个泛型类的全文，假装我是泛型类 Walterlv<T> is a sb.", 2 });
执行完之后，里面的 Walterlv<T> 真的变成了 Walterlv<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> 啊。说明成功执行。
下面进入高阶模式
作为入门篇，我才不会进入高阶模式呢！如果你想实现如本文开头所说的更通用的效果，欢迎发动你的大脑让想象力迸发。当然，如果你确实想不出来，欢迎在下方评论，我将尽快回复。
参考资料
本文会经常更新，请阅读原文： https://blog.walterlv.com/post/compile-and-invoke-code-using-roslyn.html ，以避免陈旧错误知识的误导，同时有更好的阅读体验。
本作品采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 进行许可。欢迎转载、使用、重新发布，但务必保留文章署名 吕毅 （包含链接： https://blog.walterlv.com ），不得用于商业目的，基于本文修改后的作品务必以相同的许可发布。如有任何疑问，请 与我联系 ([email protected]) 。