您可以将Enumerable.Aggregate与Expression.AndAlso结合使用。

Expression<Func<T, bool>> AndAll<T>(
    IEnumerable<Expression<Func<T, bool>>> expressions) {

    if(expressions == null) {
        throw new ArgumentNullException("expressions");
    }
    if(expressions.Count() == 0) {
        return t => true;
    }
    Type delegateType = typeof(Func<,>)
                            .GetGenericTypeDefinition()
                            .MakeGenericType(new[] {
                                typeof(T),
                                typeof(bool) 
                            }
                        );
    var combined = expressions
                       .Cast<Expression>()
                       .Aggregate((e1, e2) => Expression.AndAlso(e1, e2));
    return (Expression<Func<T,bool>>)Expression.Lambda(delegateType, combined);
}

当前代码从未赋值给combined：

expr => Expression.And(combined, expr);

传回新的Expression，它是combined和expr的比特AND运算结果，但不会变异combined。

编辑：Jason的答案在表达式树方面比我的答案更全面，所以我删除了这一部分。但是，我想留下以下内容：
我假设您要在Where子句中使用这些表达式......为什么不对每个表达式依次调用Where呢？这应该具有相同的效果：

var query = ...;
foreach (var condition in conditions)
{
    query = query.Where(condition);
}

这里我们有一个关于组合Linq表达式的一般性问题。我有一个解决这个问题的一般性方法。我将提供一个关于所发布的具体问题的答案，尽管在这种情况下这肯定不是一个正确的方法。但是当简单的解决方案在你的情况下失败时，你可以尝试使用这种方法。
首先你需要一个由两个简单函数组成的库。它们使用System.Linq.Expressions.ExpressionVisitor来动态修改表达式。关键功能是统一表达式中的参数，这样两个同名的参数就变得相同了（UnifyParametersByName）。剩下的部分是用给定的表达式（ReplacePar）替换一个命名的参数。这个库可以在github上通过MIT许可证获得：LinqExprHelper，但是您可能很快就自己编写了一些东西。
该库允许使用非常简单的语法来组合复杂的表达式。您可以将内联lambda表达式（易于阅读）与动态表达式创建和组合（功能非常强大）混合在一起。

private static Expression<Func<Company, bool>> Combine(IList<Expression<Func<Company, bool>>> expressions)
    {
        if (expressions.Count == 0)
        {
            return null;
        }

        // Prepare a master expression, used to combine other
        // expressions. It needs more input parameters, they will
        // be reduced later.
        // There is a small inconvenience here: you have to use
        // the same name "c" for the parameter in your input
        // expressions. But it may be all done in a smarter way.
        Expression <Func<Company, bool, bool, bool>> combiningExpr =
            (c, expr1, expr2) => expr1 && expr2;

        LambdaExpression combined = expressions[0];
        foreach (var expr in expressions.Skip(1))
        {
            // ReplacePar comes from the library, it's an extension
            // requiring `using LinqExprHelper`.
            combined = combiningExpr
                .ReplacePar("expr1", combined.Body)
                .ReplacePar("expr2", expr.Body);
        }
        return (Expression<Func<Company, bool>>)combined;
    }

假设你有两个表达式e1和e2，你可以这样尝试：

var combineBody = Expression.AndAlso(e1.Body, Expression.Invoke(e2, e1.Parameters[0]));
var finalExpression = Expression.Lambda<Func<TestClass, bool>>(combineBody, e1.Parameters).Compile();