如何通过Roslyn识别简化LINQ调用，完成数据库方法Session参数添加

嘿，我刚好之前处理过类似的Roslyn改造问题，这个LINQ调用识别的坑确实挺棘手的，我来给你拆解解决思路和具体实现步骤！

为什么LINQ调用难处理？ #

首先得明白：LINQ的语法糖（比如查询表达式from...select或者链式调用Where().Select()）在Roslyn的语法树里会被解析成嵌套的MethodCallSyntax节点，而且很多是扩展方法调用，和foreach循环里的直接数据库调用（比如db.Users.Add()）结构完全不一样，所以之前的逻辑识别不到很正常。

核心解决思路 #

我们需要完成三件事：

1. 遍历语法树时，识别出所有涉及数据库上下文的LINQ方法调用（不管是链式还是查询表达式）
2. 追踪这些调用所属的方法，给方法添加Session参数
3. 同步更新该方法的所有调用点，传入Session参数

具体实现步骤&代码示例 #

1. 重写CSharpSyntaxRewriter的核心方法 #

这是识别LINQ调用的入口，因为所有LINQ链式调用和查询表达式最终都会被解析成InvocationExpressionSyntax。我们结合语义分析（比纯语法判断更准确）来做识别：

public class DbCallRewriter : CSharpSyntaxRewriter
{
    private readonly SemanticModel _semanticModel;
    private readonly INamedTypeSymbol _dbSetType;
    private readonly INamedTypeSymbol _dbContextType;

    public DbCallRewriter(SemanticModel semanticModel)
    {
        _semanticModel = semanticModel;
        // 替换成你的DbContext和DbSet的元数据名称
        _dbSetType = semanticModel.Compilation.GetTypeByMetadataName("Microsoft.EntityFrameworkCore.DbSet`1");
        _dbContextType = semanticModel.Compilation.GetTypeByMetadataName("YourNamespace.YourDbContext");
    }

    public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
    {
        // 先递归处理子节点，确保内部嵌套的调用都被识别
        var updatedNode = (InvocationExpressionSyntax)base.VisitInvocationExpression(node);

        // 检查当前调用是否是数据库相关的LINQ操作
        if (IsLinqDbCall(node))
        {
            // 找到包含这个调用的方法声明
            var enclosingMethod = FindEnclosingMethod(node);
            if (enclosingMethod != null)
            {
                // 给方法添加Session参数（如果还没有的话）
                updatedNode = (InvocationExpressionSyntax)AddSessionParameter(enclosingMethod, updatedNode);
            }
        }

        return updatedNode;
    }
}

2. 实现LINQ数据库调用的判断逻辑 #

我们需要追踪LINQ方法链的根表达式，判断它是否是DbContext中的DbSet属性，同时识别常见的LINQ查询方法：

private bool IsLinqDbCall(InvocationExpressionSyntax node)
{
    // 覆盖常见的LINQ查询方法，包括同步和异步
    var linqQueryMethods = new HashSet<string>
    {
        "Where", "Select", "SelectMany", "ToList", "ToArray", "First", "FirstOrDefault",
        "Single", "SingleOrDefault", "Count", "Any", "All", "ToListAsync", "FirstOrDefaultAsync"
    };

    // 检查当前调用的方法是否属于LINQ查询方法
    var memberAccess = node.Expression as MemberAccessExpressionSyntax;
    if (memberAccess == null || !linqQueryMethods.Contains(memberAccess.Name.Identifier.Text))
    {
        return false;
    }

    // 追踪到方法链的根表达式（比如db.Users.Where(...) -> db.Users）
    var rootExpr = GetRootExpression(memberAccess.Expression);

    // 判断根表达式是否是DbContext的DbSet属性
    return IsDbContextDbSetProperty(rootExpr);
}

// 向上遍历语法树，找到方法链的最顶层表达式
private ExpressionSyntax GetRootExpression(ExpressionSyntax expr)
{
    var current = expr;
    while (current is MemberAccessExpressionSyntax memberAccess || current is InvocationExpressionSyntax invocation)
    {
        current = memberAccess != null ? memberAccess.Expression : invocation.Expression;
    }
    return current;
}

// 使用语义模型判断根表达式是否是DbContext的DbSet属性
private bool IsDbContextDbSetProperty(ExpressionSyntax expr)
{
    var symbolInfo = _semanticModel.GetSymbolInfo(expr);
    var propertySymbol = symbolInfo.Symbol as IPropertySymbol;
    if (propertySymbol == null)
    {
        return false;
    }

    // 验证属性类型是DbSet<T>，且所属类是你的DbContext
    var propertyType = propertySymbol.Type as INamedTypeSymbol;
    return propertyType != null &&
           propertyType.ConstructedFrom.Equals(_dbSetType, SymbolEqualityComparer.Default) &&
           propertySymbol.ContainingType.Equals(_dbContextType, SymbolEqualityComparer.Default);
}

3. 给方法添加Session参数并更新调用点 #

找到包含数据库调用的方法后，我们修改方法签名，同时需要同步更新所有该方法的调用点：

private MethodDeclarationSyntax FindEnclosingMethod(SyntaxNode node)
{
    var current = node.Parent;
    while (current != null)
    {
        if (current is MethodDeclarationSyntax method)
        {
            return method;
        }
        current = current.Parent;
    }
    return null;
}

private SyntaxNode AddSessionParameter(MethodDeclarationSyntax method, SyntaxNode originalNode)
{
    // 避免重复添加Session参数
    if (method.ParameterList.Parameters.Any(p => p.Identifier.Text.Equals("session", StringComparison.OrdinalIgnoreCase)))
    {
        return originalNode;
    }

    // 创建Session参数（替换成你的Session类型，比如ISession）
    var sessionParam = SyntaxFactory.Parameter(SyntaxFactory.Identifier("session"))
        .WithType(SyntaxFactory.IdentifierName("ISession"))
        .WithLeadingTrivia(SyntaxFactory.Space);

    // 更新方法的参数列表
    var updatedMethod = method.WithParameterList(
        method.ParameterList.AddParameters(sessionParam)
    );

    // 额外步骤：更新该方法的所有调用点
    // 可以通过SemanticModel的FindReferences方法找到所有调用，再修改参数列表
    // 这里简化示例，返回更新后的方法节点
    return updatedMethod;
}

额外注意事项 #

• 查询表达式支持：不用专门处理from...select写法，Roslyn会自动把它解析成链式的MethodCallSyntax，上面的逻辑完全能识别
• 异步LINQ方法：记得把ToListAsync、FirstOrDefaultAsync这类异步方法加入到查询方法集合中
• 语义模型的必要性：纯语法分析容易误判（比如用户自己写了一个叫Where的方法），用语义模型判断类型是最可靠的方式
• 调用点更新：上面的示例只处理了方法签名，实际项目中还需要遍历所有调用该方法的地方，添加Session参数，这部分可以通过SemanticModel.FindReferences方法实现

内容的提问来源于stack exchange，提问作者jrandomuser