如何直接将Expression转换为CSharpCompilation或CSharpSyntaxTree？

If you need to convert Expression<TDelegate> instances directly to CSharpSyntaxTree or CSharpCompilation (skipping string serialization/parsing entirely), the solution hinges on combining .NET's ExpressionVisitor with Roslyn's SyntaxFactory API to build syntax nodes programmatically. This approach guarantees behavioral parity between the original expression and generated code, while avoiding the overhead and parsing errors that come with string-based conversion.

Core Approach: Expression Visitor + SyntaxFactory #

The key idea is to build a custom ExpressionVisitor that traverses each node in your expression tree and maps it to the equivalent Roslyn syntax node using SyntaxFactory methods. Every expression type—lambda, binary operation, parameter, method call, etc.—gets its own visitor method to construct the matching syntax element.

Sample Implementation #

Here’s a simplified visitor that handles basic lambda expressions, parameters, binary operations, and constants (you’ll want to extend this for full coverage):

using System.Linq.Expressions;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;

public class ExpressionToSyntaxVisitor : ExpressionVisitor
{
    public SyntaxNode VisitAndConvert(Expression expression)
    {
        return Visit(expression) ?? throw new InvalidOperationException("Failed to convert expression to syntax");
    }

    protected override Expression VisitLambda<T>(Expression<T> node)
    {
        // Convert expression parameters to Roslyn parameter syntax
        var parameters = node.Parameters.Select(p => SyntaxFactory.Parameter(
            attributes: SyntaxFactory.List<AttributeListSyntax>(),
            modifiers: SyntaxFactory.TokenList(),
            type: SyntaxFactory.ParseTypeName(p.Type.FullName ?? p.Type.Name),
            identifier: SyntaxFactory.Identifier(p.Name),
            initializer: null)).ToList();

        var parameterList = SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameters));
        var body = (ExpressionSyntax)Visit(node.Body);

        // Wrap the lambda in a static method for compilation (adjust based on your use case)
        var method = SyntaxFactory.MethodDeclaration(
            returnType: SyntaxFactory.ParseTypeName(typeof(T).GetMethod("Invoke")!.ReturnType.FullName!),
            identifier: "GeneratedLambdaMethod")
        .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword), SyntaxFactory.Token(SyntaxKind.StaticKeyword))
        .WithParameterList(parameterList)
        .WithBody(SyntaxFactory.Block(SyntaxFactory.ReturnStatement(body)));

        return method;
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        return SyntaxFactory.IdentifierName(node.Name);
    }

    protected override Expression VisitBinary(BinaryExpression node)
    {
        var left = (ExpressionSyntax)Visit(node.Left);
        var right = (ExpressionSyntax)Visit(node.Right);
        
        // Map expression operator types to Roslyn syntax tokens
        var opToken = node.NodeType switch
        {
            ExpressionType.Add => SyntaxFactory.Token(SyntaxKind.PlusToken),
            ExpressionType.Multiply => SyntaxFactory.Token(SyntaxKind.AsteriskToken),
            ExpressionType.Subtract => SyntaxFactory.Token(SyntaxKind.MinusToken),
            ExpressionType.Divide => SyntaxFactory.Token(SyntaxKind.SlashToken),
            _ => throw new NotSupportedException($"Binary operator {node.NodeType} isn't implemented yet")
        };

        return SyntaxFactory.BinaryExpression(opToken, left, right);
    }

    protected override Expression VisitConstant(ConstantExpression node)
    {
        // Handle numeric constants (extend for strings, booleans, etc.)
        if (node.Value is int intVal)
            return SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(intVal));
        
        throw new NotSupportedException($"Constant type {node.Type.Name} isn't implemented yet");
    }
}

Generating Syntax Tree & Compilation #

Once you have the visitor, use it to build a CSharpSyntaxTree and then a fully functional CSharpCompilation:

// Example expression: (int x, int y) => x + y * 2
Expression<Func<int, int, int>> sampleExpr = (x, y) => x + y * 2;

var visitor = new ExpressionToSyntaxVisitor();
var methodSyntax = (MethodDeclarationSyntax)visitor.VisitAndConvert(sampleExpr);

// Build a complete compilation unit with namespace and class
var compilationUnit = SyntaxFactory.CompilationUnit()
    .AddMembers(SyntaxFactory.NamespaceDeclaration(SyntaxFactory.IdentifierName("MyGeneratedCode"))
        .AddMembers(SyntaxFactory.ClassDeclaration("ExpressionGeneratedClass")
            .AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword))
            .AddMembers(methodSyntax)));

// Create the syntax tree
var syntaxTree = CSharpSyntaxTree.Create(compilationUnit);

// Build the compilation with necessary references
var compilation = CSharpCompilation.Create("MyGeneratedAssembly")
    .AddReferences(MetadataReference.CreateFromFile(typeof(object).Assembly.Location))
    .AddSyntaxTrees(syntaxTree);

// Optional: Emit the assembly to a stream or file
using var stream = new MemoryStream();
var emitResult = compilation.Emit(stream);

if (!emitResult.Success)
{
    foreach (var error in emitResult.Diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error))
    {
        Console.WriteLine($"Compilation Error: {error.GetMessage()}");
    }
}

Ensuring Behavioral Consistency #

To make sure the generated code behaves exactly like your original expression:

• Cover all expression types: Extend the visitor to handle method calls, property accesses, conditional expressions, null-coalescing operators, generics, and nullable types.
• Preserve full type information: Use Type.FullName instead of just Name to avoid ambiguity with nested or imported types.
• Handle closures correctly: If your expression captures external variables, generate fields in the target class to hold those values and initialize them during compilation.
• Test edge cases: Validate with expressions involving overloaded operators, nullable value types, and complex object graphs to catch discrepancies.

Use Cases #

This approach shines in scenarios like:

• DI/IoC Containers: Dynamically compile factory methods from expression-based registrations to avoid reflection overhead at runtime.
• ORMs: Translate LINQ query expressions into compileable in-memory filters or SQL execution logic.
• Message Buses: Serialize expression-based message handlers as compiled code for efficient cross-endpoint execution.
• Dynamic Code Generation: Any situation where you need strongly-typed, compileable C# code from runtime expressions without string parsing.

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