如何将Expression<Func<T,object>>转字符串时移除多余Convert方法

需要将Expression<Func<Person, object>>类型的表达式转换为字符串，用于后续源代码生成场景。直接调用表达式的ToString()方法时，返回值为值类型的表达式会被自动插入装箱转换的Convert节点，导致输出结果不符合预期：

• 正常场景（返回引用类型）：

Expression<Func<Person,object>> exp1 = p => "abc";  
Console.WriteLine(exp1.ToString() ); 
// 输出：p => "abc"，符合预期

• 异常场景（返回值类型）：

Expression<Func<Person,object>> exp2 = p =>  Guid.NewGuid();
Console.WriteLine(exp2.ToString()); 
// 实际输出：p => Convert(NewGuid(), Object)
// 期望输出：p => Guid.NewGuid()

多余的Convert节点会导致后续生成的源代码出现编译错误，需要移除这类自动生成的装箱转换包装，获取原始表达式的字符串形式。

当Lambda表达式的返回值为值类型时，C#编译器会自动在表达式树中插入Convert(xxx, object)的装箱节点，完成值类型到object的隐式转换，匹配委托的返回值定义。这部分节点是表达式树的真实组成部分，并非ToString()方法额外生成。字符串是引用类型，不需要装箱操作，因此不会生成多余的Convert节点。

编写递归方法遍历表达式树，识别并剥离编译器自动插入的多余装箱Convert节点，再用处理后的表达式主体重新生成Lambda表达式，最后调用ToString()即可得到干净的输出。
判定多余装箱Convert节点的规则：

• 节点类型为ExpressionType.Convert或ExpressionType.ConvertChecked
• 转换目标类型为object
• 转换源类型为值类型
• 不存在用户自定义的转换方法（排除用户显式写的类型转换逻辑）

完整实现代码：

using System.Linq.Expressions;

public static class ExpressionExtensions
{
    public static string ToSourceCompatibleString(this LambdaExpression expression)
    {
        Expression cleanedBody = RemoveRedundantBoxConvert(expression.Body);
        return Expression.Lambda(cleanedBody, expression.Parameters).ToString();
    }

    private static Expression RemoveRedundantBoxConvert(Expression node)
    {
        switch (node)
        {
            case UnaryExpression unaryExpr:
                if (IsCompilerGeneratedBoxConvert(unaryExpr))
                {
                    return RemoveRedundantBoxConvert(unaryExpr.Operand);
                }
                return unaryExpr.Update(RemoveRedundantBoxConvert(unaryExpr.Operand));
            case BinaryExpression binaryExpr:
                return binaryExpr.Update(
                    RemoveRedundantBoxConvert(binaryExpr.Left),
                    binaryExpr.Conversion,
                    RemoveRedundantBoxConvert(binaryExpr.Right)
                );
            case MethodCallExpression callExpr:
                return callExpr.Update(
                    RemoveRedundantBoxConvert(callExpr.Object),
                    callExpr.Arguments.Select(RemoveRedundantBoxConvert)
                );
            case MemberExpression memberExpr:
                return memberExpr.Update(RemoveRedundantBoxConvert(memberExpr.Expression));
            case NewExpression newExpr:
                return newExpr.Update(newExpr.Arguments.Select(RemoveRedundantBoxConvert));
            case ConditionalExpression conditionalExpr:
                return conditionalExpr.Update(
                    RemoveRedundantBoxConvert(conditionalExpr.Test),
                    RemoveRedundantBoxConvert(conditionalExpr.IfTrue),
                    RemoveRedundantBoxConvert(conditionalExpr.IfFalse)
                );
            default:
                return node;
        }
    }

    private static bool IsCompilerGeneratedBoxConvert(UnaryExpression unaryExpr)
    {
        if (unaryExpr.NodeType != ExpressionType.Convert && unaryExpr.NodeType != ExpressionType.ConvertChecked)
            return false;
        if (unaryExpr.Type != typeof(object))
            return false;
        if (!unaryExpr.Operand.Type.IsValueType)
            return false;
        if (unaryExpr.Method != null)
            return false;
        return true;
    }
}

使用方式：

Expression<Func<Person,object>> exp2 = p => Guid.NewGuid();
Console.WriteLine(exp2.ToSourceCompatibleString());
// 输出：p => Guid.NewGuid()，符合预期

如果业务中用到其他表达式类型（如块表达式、集合初始化表达式等），只需在RemoveRedundantBoxConvert方法的switch分支中补充对应类型的子节点递归处理逻辑即可，处理规则保持一致。

内容的提问来源于stack exchange，提问作者M.Hassan