能否基于接收Y类型的Expression创建接收包含Y的X类型的Expression？

当然可以实现这个需求！咱们结合你给出的类型定义和ExprY函数，一步步把接收Y的表达式转换成接收X的表达式——毕竟X里包含了Y属性，本质就是把表达式的参数上下文从Y切换到X.Y。

基础类型与原表达式函数 #

先把你的基础代码贴出来方便对照：

public class Y 
{ 
    public int Something { get; set; } 
} 

public class X 
{ 
    public Y Y { get; set; } 
}

private static Expression<Func<Y, bool>> ExprY(Y y2) 
{ 
    return y1 => y1.Something == y2.Something; 
}

核心实现：表达式参数替换 #

要完成转换，最稳妥的方式是用ExpressionVisitor遍历原表达式树，把所有指向Y类型参数的地方替换成X.Y属性。这种方式生成的表达式树能被大多数ORM（比如EF Core）正确解析，兼容性拉满。

首先写一个自定义的参数替换访问器：

private class ParameterReplacer : ExpressionVisitor
{
    private readonly ParameterExpression _oldParameter;
    private readonly Expression _replacementExpression;

    public ParameterReplacer(ParameterExpression oldParameter, Expression replacementExpression)
    {
        _oldParameter = oldParameter;
        _replacementExpression = replacementExpression;
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        // 匹配到要替换的参数时，返回新的表达式，否则保持原样
        return node == _oldParameter ? _replacementExpression : base.VisitParameter(node);
    }
}

然后写转换函数，把Expression<Func<Y, bool>>转换成Expression<Func<X, bool>>：

private static Expression<Func<X, bool>> ConvertToXExpression(Expression<Func<Y, bool>> yExpression)
{
    // 创建X类型的参数（对应lambda里的x）
    var xParameter = Expression.Parameter(typeof(X), "x");
    // 获取x.Y这个属性表达式
    var xYProperty = Expression.Property(xParameter, nameof(X.Y));
    // 替换原表达式中的Y参数为x.Y
    var newBody = new ParameterReplacer(yExpression.Parameters[0], xYProperty).Visit(yExpression.Body);
    // 构建新的Lambda表达式
    return Expression.Lambda<Func<X, bool>>(newBody, xParameter);
}

使用示例 #

现在来测试一下转换后的表达式是否正常工作：

// 原表达式的输入参数
var targetY = new Y { Something = 42 };
// 获取原表达式
var yExpr = ExprY(targetY);
// 转换成X的表达式
var xExpr = ConvertToXExpression(yExpr);

// 编译成委托测试
var xFunc = xExpr.Compile();
var matchX = new X { Y = new Y { Something = 42 } };
var noMatchX = new X { Y = new Y { Something = 100 } };

Console.WriteLine(xFunc(matchX)); // 输出 True
Console.WriteLine(xFunc(noMatchX)); // 输出 False

额外说明：另一种简化方式（谨慎使用） #

如果你不需要考虑ORM兼容性，也可以用Expression.Invoke快速实现，但这种方式生成的表达式树包含Invoke节点，部分ORM无法解析：

private static Expression<Func<X, bool>> ConvertToXExpressionWithInvoke(Expression<Func<Y, bool>> yExpression)
{
    var xParameter = Expression.Parameter(typeof(X), "x");
    // 直接调用原表达式，传入x.Y作为参数
    var invokeExpr = Expression.Invoke(yExpression, Expression.Property(xParameter, nameof(X.Y)));
    return Expression.Lambda<Func<X, bool>>(invokeExpr, xParameter);
}

所以优先推荐第一种参数替换的方式，兼容性更好。

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