@YvesDarmaillacのコードを機能させることはできませんでしたが、この解決策を示しました。
式を作成してから、各条件を個別に追加できます。これを行うには、Universal PredicateBuilder（最後のソース）を使用できます。
これが私のコードです：
// First we create an Expression. Since we can't create an empty one,
// we make it return false, since we'll connect the subsequent ones with "Or".
// The following could also be: Expression<Func<Location, bool>> condition = (x => false);
// but this is clearer.
var condition = PredicateBuilder.Create<Location>(x => false);
foreach (var key in keys)
{
// each one returns a new Expression
condition = condition.Or(
x => x.Country == key.Country && x.City == key.City && x.Address == key.Address
);
}
using (var ctx = new MyContext())
{
var locations = ctx.Locations.Where(condition);
}
ただし、注意すべき点の1つは、フィルターリスト（keysこの例では変数）が大きすぎないことです。そうしないと、次のような例外を除いて、パラメーターの制限に達する可能性があります。
SqlException：着信リクエストのパラメータが多すぎます。サーバーは最大2100個のパラメーターをサポートします。パラメーターの数を減らして、要求を再送信してください。
したがって、この例（1行に3つのパラメーターを使用）では、フィルターする場所を700を超えることはできません。
2つの項目を使用してフィルタリングすると、最終的なSQLで6つのパラメーターが生成されます。生成されたSQLは次のようになります（より明確になるようにフォーマットされています）。
exec sp_executesql N'
SELECT
[Extent1].[Id] AS [Id],
[Extent1].[Country] AS [Country],
[Extent1].[City] AS [City],
[Extent1].[Address] AS [Address]
FROM [dbo].[Locations] AS [Extent1]
WHERE
(
(
([Extent1].[Country] = @p__linq__0)
OR
(([Extent1].[Country] IS NULL) AND (@p__linq__0 IS NULL))
)
AND
(
([Extent1].[City] = @p__linq__1)
OR
(([Extent1].[City] IS NULL) AND (@p__linq__1 IS NULL))
)
AND
(
([Extent1].[Address] = @p__linq__2)
OR
(([Extent1].[Address] IS NULL) AND (@p__linq__2 IS NULL))
)
)
OR
(
(
([Extent1].[Country] = @p__linq__3)
OR
(([Extent1].[Country] IS NULL) AND (@p__linq__3 IS NULL))
)
AND
(
([Extent1].[City] = @p__linq__4)
OR
(([Extent1].[City] IS NULL) AND (@p__linq__4 IS NULL))
)
AND
(
([Extent1].[Address] = @p__linq__5)
OR
(([Extent1].[Address] IS NULL) AND (@p__linq__5 IS NULL))
)
)
',
N'
@p__linq__0 nvarchar(4000),
@p__linq__1 nvarchar(4000),
@p__linq__2 nvarchar(4000),
@p__linq__3 nvarchar(4000),
@p__linq__4 nvarchar(4000),
@p__linq__5 nvarchar(4000)
',
@p__linq__0=N'USA',
@p__linq__1=N'NY',
@p__linq__2=N'Add1',
@p__linq__3=N'UK',
@p__linq__4=N'London',
@p__linq__5=N'Add2'
最初の「false」式が適切に無視され、EntityFrameworkによって最終的なSQLに含まれていないことに注意してください。
最後に、レコード用のUniversalPredicateBuilderのコードを次に示します。
/// <summary>
/// Enables the efficient, dynamic composition of query predicates.
/// </summary>
public static class PredicateBuilder
{
/// <summary>
/// Creates a predicate that evaluates to true.
/// </summary>
public static Expression<Func<T, bool>> True<T>() { return param => true; }
/// <summary>
/// Creates a predicate that evaluates to false.
/// </summary>
public static Expression<Func<T, bool>> False<T>() { return param => false; }
/// <summary>
/// Creates a predicate expression from the specified lambda expression.
/// </summary>
public static Expression<Func<T, bool>> Create<T>(Expression<Func<T, bool>> predicate) { return predicate; }
/// <summary>
/// Combines the first predicate with the second using the logical "and".
/// </summary>
public static Expression<Func<T, bool>> And<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
{
return first.Compose(second, Expression.AndAlso);
}
/// <summary>
/// Combines the first predicate with the second using the logical "or".
/// </summary>
public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> first, Expression<Func<T, bool>> second)
{
return first.Compose(second, Expression.OrElse);
}
/// <summary>
/// Negates the predicate.
/// </summary>
public static Expression<Func<T, bool>> Not<T>(this Expression<Func<T, bool>> expression)
{
var negated = Expression.Not(expression.Body);
return Expression.Lambda<Func<T, bool>>(negated, expression.Parameters);
}
/// <summary>
/// Combines the first expression with the second using the specified merge function.
/// </summary>
static Expression<T> Compose<T>(this Expression<T> first, Expression<T> second, Func<Expression, Expression, Expression> merge)
{
// zip parameters (map from parameters of second to parameters of first)
var map = first.Parameters
.Select((f, i) => new { f, s = second.Parameters[i] })
.ToDictionary(p => p.s, p => p.f);
// replace parameters in the second lambda expression with the parameters in the first
var secondBody = ParameterRebinder.ReplaceParameters(map, second.Body);
// create a merged lambda expression with parameters from the first expression
return Expression.Lambda<T>(merge(first.Body, secondBody), first.Parameters);
}
class ParameterRebinder : ExpressionVisitor
{
readonly Dictionary<ParameterExpression, ParameterExpression> map;
ParameterRebinder(Dictionary<ParameterExpression, ParameterExpression> map)
{
this.map = map ?? new Dictionary<ParameterExpression, ParameterExpression>();
}
public static Expression ReplaceParameters(Dictionary<ParameterExpression, ParameterExpression> map, Expression exp)
{
return new ParameterRebinder(map).Visit(exp);
}
protected override Expression VisitParameter(ParameterExpression p)
{
ParameterExpression replacement;
if (map.TryGetValue(p, out replacement))
{
p = replacement;
}
return base.VisitParameter(p);
}
}
}