经过大量的挖掘，我找到了解决我的问题，通过这篇文章：
在c#中将表达式的一部分定义为变量
我添加了一个新的辅助函数：

public static Expression<Func<CMSiteServer, bool>> GetSiteExpressionForServer(CMSiteFilter filter, bool Active)
{
     var exp = GetSiteExpression(filter, Active);
     return exp.ApplyTo((CMSiteServer x) => x.CMSite);
}

结合文章中的帮助函数：

public static Expression<Func<TOuter, TResult>> Bind<TOuter, TInner, TResult>(this Expression<Func<TOuter, TInner>> source, Expression<Func<TInner, TResult>> resultSelector)
{
     var body = new ParameterExpressionReplacer { source = resultSelector.Parameters[0], target = source.Body }.Visit(resultSelector.Body);
     var lambda = Expression.Lambda<Func<TOuter, TResult>>(body, source.Parameters);
     return lambda;
}

public static Expression<Func<TOuter, TResult>> ApplyTo<TInner, TResult, TOuter>(this Expression<Func<TInner, TResult>> source, Expression<Func<TOuter, TInner>> innerSelector)
{
     return innerSelector.Bind(source);
}

此外，我还解决了处理多个过滤条件IEnumerable的相关用例，其中每个条件都是“或”，例如，其中@{}是过滤对象@{Name == 'A'}，@{Name == 'B'}，@{ID == 4}
应组成以下SQL条件：（名称=“A”或名称=“B”或ID = 4）

// function convert a list of filters into a new expression that combines them together
public static Expression<Func<CMSite, bool>> GetServerExpression(IEnumerable<CMSiteServerFilter> filters, bool Active)
    {
        // make sure we got some filters
        if (filters == null)
            return (s => true);

        // compile the list of expressions, one for each filter
        var expressions = filters.Select((f) => GetServerExpression(f, Active)).ToList();

        // if no expressions, we are done
        if (expressions.Count == 0)
            return (s => true);

        //set our initial condition, since we are using "OR" we want to default to false
        Expression<Func<CMSiteServer, bool>> exp = (s => false);
        // merge the multiple expressions into a new single expression
        foreach (var e in expressions)
            exp = exp.Or(e);

        // apply the combined expression to our list of servers
        return (s => s.CMSiteServers.AsQueryable().Where(exp).Any());
    }

上面的“Or”扩展名来自于这篇文章：Combining two expressions (Expression<Func<T, bool>>)

public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> a, Expression<Func<T, bool>> b)
{

        ParameterExpression p = a.Parameters[0];

        SubstExpressionVisitor visitor = new SubstExpressionVisitor();
        visitor.subst[b.Parameters[0]] = p;

        Expression body = Expression.OrElse(a.Body, visitor.Visit(b.Body));
        return Expression.Lambda<Func<T, bool>>(body, p);
}

//And the utility class to substitute the parameters in a lambda:
internal class SubstExpressionVisitor : ExpressionVisitor
{
    public Dictionary<Expression, Expression> subst = new Dictionary<Expression, Expression>();

    protected override Expression VisitParameter(ParameterExpression node)
    {
        Expression newValue;
        if (subst.TryGetValue(node, out newValue))
        {
            return newValue;
        }
        return node;
    }
}