深入理解 Roslyn：从语法树到动态编译实战

这段字符串中包含 5 个 using 引用，一个类型声明，2 个方法（1 个带参数空返回值，1 个不带参数空返回值）。

然后我们使用 VS 打开这个代码，用可视化语法树工具查看，你就能理解为什么叫语法树分析了。左边是源代码，右边就是工具分析出的这个源代码的语法树结构。第一层根节点叫【CompilationUnit】又叫编译单元，相当于一个文件就是一个单独的编译单元，而且呈现树形生长。你把鼠标移到对应的源代码元素上，都会在右侧可视化工具中找到对应的树节点。

这里面有不同的颜色标记的都叫做一个语法：

• 语法节点（SyntaxNode）：被标记为蓝色，例如方法、类、表达式等。
• 语法标记（SyntaxToken）：被标记为绿色，例如关键字 static、void，VoidKeyword 就代表空返回值。
• 语法杂项（SyntaxTrivia）：被标记为红色，例如一些空格注释。

Syntax 语法 API

Syntax 类型用于表示源代码的语法结构，是构建和操作 C# 代码抽象语法树（AST）的基础。

一般语法树从大到小：

• using 指令 - UsingDirectiveSyntax
• 成员定义的语法 - MemberDeclarationSyntax（每一个 node 都包含有 MemberDeclarationSyntax）
• 命名空间语法 - NamespaceDeclarationSyntax
• 类定义语法 - ClassDeclarationSyntax
• 方法定义语法 - MethodDeclarationSyntax
• 参数定义语法 - ParameterSyntax

可以访问这个网站：https://roslynquoter.azurewebsites.net/ 然后把代码粘贴进去点击生成就会出现以下内容。

我们思考下，我们都拿到了代码的逻辑语法结构，是不是找什么就容易了？因为源代码的每一个字符，每一个代码都对应一个语法标记。现在知道为什么我们使用 VS 开发代码时，有时候没写括号或者少了标点，就会提示错误了吧？其实就是实时在检测您写的代码的语法树，是不是符合规则，如果不符合就产生对应的错误。

看着头疼，如果不能理解可以指出。读不懂没有关系，因为这一步是主要说明什么是语法树和语法结构，可以判断你的结构对不对。那如何判断内容和意义对不对呢？接着往下看！

语义分析

例如我一个方法返回值是 Int，我返回一个 string：

static int Main2()
{
    return "1";
}

再分别看可视化的语法树也正常长出来了，在线的分析工具也能分析出来。但是我们作为开发人员肯定知道，我要 INT 你返回 string，能用才怪呢，逻辑就对不上。在 VS 中飘红是因为他有检测，如果你用记事本写，是不是没啥问题，符合 C# 语法，但它没有足够的信息来标识所引用的内容是什么意思。因为名称可能表示一种类型，方法，局部变量，语义不一样。这个时候就要说另外一个东西了，就是语义分析，就是我解析生成了语法结构，我还得知道每个节点代表什么意思，他的意义是什么。只有知道了语义之后才能真正'活'起来。

利用 Roslyn API 进行语法以及语义分析

先定义代码字符串，因为在编译时 Roslyn 就是将源代码文件作为字符串读取，形成上面描述那样的语法树逻辑结构。

public const string ProgramText = @"
using System;
using System.Collections;
using System.Linq;
using System.Text;
using Microsoft.CodeAnalysis;

namespace HelloWorld
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, World!");
        }

        static void Main1()
        {
            var list = new List() { "21" };
            list.Add("c");
            Console.WriteLine("Hello, Main1!");
        }
    }
}";

1. 语法分析

直接从语法节点获取返回类型 && 使用语法树分析遍历每个节点。

static void Main(string[] args)
{
    SyntaxTree tree = CSharpSyntaxTree.ParseText(ProgramText);
    CompilationUnitSyntax root = tree.GetCompilationUnitRoot();
    
    WriteLine($"语法树有 {root.Members.Count} 个元素在里面.");
    WriteLine($"这个语法树有 {root.Usings.Count} using 语句，分别是:");
    foreach (UsingDirectiveSyntax element in root.Usings)
        WriteLine($"\t{element.Name}");

    MemberDeclarationSyntax firstMember = root.Members[0];
    WriteLine($"第一个成员是：{firstMember.Kind()}.");
    
    var helloWorldDeclaration = (NamespaceDeclarationSyntax)firstMember;
    WriteLine($"命名空间{helloWorldDeclaration.Name}下声明了 {helloWorldDeclaration.Members.Count} 个成员.");
    WriteLine($"第一个成员的类型是：{helloWorldDeclaration.Members[0].Kind()}.");
    
    var programDeclaration = (ClassDeclarationSyntax)helloWorldDeclaration.Members[0];
    WriteLine($"有 {programDeclaration.Members.Count} 个成员定义在 {programDeclaration.Identifier} 类中.");

    //直接从语法节点获取返回类型
    for (int i = 0; i < programDeclaration.Members.Count; i++)
    {
        WriteLine($"第{i+1}个成员是一个 {programDeclaration.Members[i].Kind()}类型.");
        var mainDeclaration = (MethodDeclarationSyntax)programDeclaration.Members[i];
        WriteLine($"{mainDeclaration.Identifier}：方法的返回类型是：{mainDeclaration.ReturnType}.");
        WriteLine($"方法有：{mainDeclaration.ParameterList.Parameters.Count} 个参数.");
        
        foreach (ParameterSyntax item in mainDeclaration.ParameterList.Parameters)
            WriteLine($"{item.Identifier} 参数的类型是：{item.Type}.");
            
        WriteLine($"{mainDeclaration.Identifier} 方法体内容如下:");
        WriteLine(mainDeclaration.Body.ToFullString());
    }
}

输出结果会显示语法树的层级结构，比如命名空间、类、方法、参数等信息。是不是感觉理解了一些？接着看语法分析可以拿到你的代码块中你想关注的更多有用的信息。

2. 语义分析

接下来我们开始进行语义分析，说白了就是：在语法结构正确的基础上，搞清楚这段代码到底要干什么。它会顺着语法树，一层层看懂每个部分的真正含义，比如变量是谁、函数怎么用、类型对不对，最后把程序的'真实意图'给挖出来。

// 为 programText 常量中的代码文本生成语法树
SyntaxTree tree = CSharpSyntaxTree.ParseText(ProgramText);
CompilationUnitSyntax root = tree.GetCompilationUnitRoot();

var compilation = CSharpCompilation.Create("HelloWorld")
    .AddReferences(MetadataReference.CreateFromFile(typeof(string).Assembly.Location))
    .AddSyntaxTrees(tree);

var methods2 = (from methodDeclaration in root.DescendantNodes()
                .OfType<MethodDeclarationSyntax>()
                select methodDeclaration).ToList();

//遍历语法节点，找到所有的方法定义
foreach (var item in methods2)
{
    //获取整个语义模型
    var model = compilation.GetSemanticModel(tree);
    //根据当前语法节点，利用语义模型找到当前方法的符号
    var semanticMethod = model.GetDeclaredSymbol(item);
    //获取当前方法的返回值
    Console.WriteLine(semanticMethod.ReturnType);
}

其实语义分析的重点就是 compilation.GetSemanticModel(tree)，他的作用就是得到一个语义模型，然后通过它可以查询出，当前分析的这段代码的意思，他在这个范围内的名称是什么，他可以访问哪些成员，定义了哪些变量。

如果您还没体会到好处，可能不太深刻，可以按照例子自己试试。

扩展

看了上面的语法和语义分析，您可能还是有点懵，说了一大堆，拿到了有啥用，看了跟没看一样，他能做什么。不过不要紧，在这里我尽可能的让您知道他的好处。

相信您只要做了开发，一定对在代码中提交事务不会陌生吧。在团队开发中，曾几何时是否有忘记过写 Commit() 然后发现一顿操作无效？又或者在团队开发中，有些人的代码总是不合要求，让入参小写，非要大写，方法名让大写，他小写，等到一段时间之后，代码看着痛苦不堪。又或者上线后因为异步方法使用 void 来作为方法返回值，产生了莫名其妙的异常，查了半天，还没搞定，最后回滚代码。

但是作为技术 leader 或者高级开发的你精力有限，不可能每个人我都去盯着吧，就这样不知所措.... 此时你想要是能在一开始就不让写这样的代码不就好了，就像我在 VS 写的时候直接飘红，那我怎么弄呢？恭喜您已经入门了，这时候就可以自己定义一个代码分析器来检查这些问题。

上面已经提到 Roslyn 的一个重要应用场景就是代码分析。Roslyn 的特点和作用，我们在语法和语义分析部分已经大概了解，联想一下，是不是若有所思？思路如下：

1. 通过 Roslyn 解析我的代码，然后解析出语法结构和语义模型。
2. 根据语法树，我找到所有的方法节点，然后通过语义解析出，找到所有的 Task 方法，将符合并且返回值是 void 的直接调出来是不是就可以了。

但是也不要被此局限，因为他提供的远不止我简单描述的做这些。

用 Roslyn 打造代码规约和动态编译

1. 用 Roslyn 构建代码规范检查器，禁止 async void 方法

① 创建自定义分析器

我们定义一个类 UserDiagnosticAnalyzer，继承自 DiagnosticAnalyzer，并标注 [DiagnosticAnalyzer(LanguageNames.CSharp)]，表明这是一个针对 C# 语言的语法分析器。

[DiagnosticAnalyzer(LanguageNames.CSharp)]
public class UserDiagnosticAnalyzer : DiagnosticAnalyzer
{
    // ...
}

② 定义诊断规则

通过 DiagnosticDescriptor 定义一条诊断规则，当检测到违规代码时，输出一条错误信息，例如'异步方法不能返回 void'。

private static DiagnosticDescriptor Rule = new DiagnosticDescriptor(
    id: "Code001",
    title: "示例规则标题",
    messageFormat: "代码规范检查：{0}",
    category: "Usage",
    defaultSeverity: DiagnosticSeverity.Error,
    isEnabledByDefault: true
);

③ 注册分析逻辑

在 Initialize 方法中，我们注册一个语法节点分析动作，监听所有方法声明（MethodDeclaration）节点：

public override void Initialize(AnalysisContext context)
{
    context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
    context.EnableConcurrentExecution();
    context.RegisterSyntaxNodeAction(AnalyzeSymbolAnalysisContext, SyntaxKind.MethodDeclaration);
}

EnableConcurrentExecution() 提升分析性能；RegisterSyntaxNodeAction 指定当解析到方法声明时，调用 AnalyzeSymbolAnalysisContext 进行分析。

④ 实现分析逻辑

在回调方法中，我们判断方法是否同时满足两个条件：包含 async 关键字；返回类型为 void。

private static void AnalyzeSymbolAnalysisContext(SyntaxNodeAnalysisContext context)
{
    if (context.Node is MethodDeclarationSyntax method)
    {
        if (method.Modifiers.Any(x => x.IsKind(SyntaxKind.AsyncKeyword))
            && method.ReturnType.ToString() == "void")
        {
            var diagnostic = Diagnostic.Create(
                Rule,
                context.Node.GetLocation(),
                "异步方法不能返回 void"
            );
            context.ReportDiagnostic(diagnostic);
        }
    }
}

然后在业务代码中引用，当你写这种不符合规范的代码，IDE 会立即在代码下方显示红色波浪线，就会提示错误。

2. 使用 Roslyn 来动态编译代码

它的另外一个作用就是动态编译。Roslyn 不仅仅是一个编译器平台，它还提供了强大的动态编译与代码执行能力，这一特性在构建可扩展的中后台系统时很实用。

举个典型的场景：我们有一个底层通用功能平台（比如审批流程、数据校验、报表生成等），多个业务系统都基于这个平台进行开发。虽然核心逻辑是通用的，但每个业务方可能需要在标准流程中插入自定义逻辑，比如在某个方法执行前后修改数据、记录日志、调用特定服务等。

传统做法是通过接口 + 插件模式或依赖注入来实现扩展，但这要求编译期就确定实现类，不够灵活。而借助 Roslyn 的动态编译能力，我们可以让业务开发人员以脚本形式编写扩展逻辑，在运行时动态编译并执行，真正做到热插拔式的定制。

我们定义一个通用的数据处理流程，在关键节点允许业务方传入一段 C# 脚本：

var script = @"parameters.Value += 1;";
var action = RoslynScriptRunner.CreateScript(script);
AA aA1 = new AA();
aA1.Value = 99;
action.Invoke(aA1);
Console.WriteLine(aA1.Value); // 输出 100

在这个例子中：

• AA 是我们约定的数据上下文对象。
• script 是由业务方提供的 C# 表达式脚本，表示对 Value 加 1。
• RoslynScriptRunner 是封装了 Roslyn 编译和执行逻辑的工具类。

在运行时，平台动态编译这段脚本，并将业务对象 aA1 作为参数传入执行。这样一来，不同业务系统可以在不修改主流程代码的前提下，灵活注入自己的逻辑，实现真正的运行时扩展。

这种模式特别适用于：

• 需要频繁变更的业务规则；
• 多租户系统中的个性化定制；
• 平台化产品中开放二次开发能力。