LINQ to entities - où..dans la clause avec plusieurs colonnes

Bien que je ne pouvais pas obtenir @YvesDarmaillac du code du travail, il m'a indiqué cette solution.

Vous pouvez créer une expression, puis ajouter chaque état séparément. Pour ce faire, vous pouvez utiliser l'Universel PredicateBuilder (de la source à la fin).

Voici mon code:

//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);
}

Une chose à garder de, bien que, est que le filtre de la liste (le keys variable dans cet exemple) ne peut pas être trop grande, ou vous pouvez joindre les paramètres de limite, avec une exception comme ceci:

SqlException: La demande entrante a trop de paramètres. Le serveur prend en charge un maximum de 2100 paramètres. Réduire le nombre de paramètres et renvoyer la demande.

Donc, dans cet exemple (avec trois paramètres par ligne), vous ne pouvez pas avoir plus de 700 Emplacements de filtre.

À l'aide de deux éléments de filtre, il va générer des 6 paramètres lors de la finale de SQL. Le SQL généré va ressembler à ci-dessous (mise en forme pour être plus clair):

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'

Remarquez comment les initiales "false" l'expression est correctement ignorés et ne sont pas inclus dans la version finale de SQL par EntityFramework.

Enfin, voici le code pour le Universel PredicateBuilder, pour l'enregistrement.

///<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);
}
}
}

OriginalL'auteur Marcos Dimitrio

var result = from loc in Location
where keys.Contains(new {
Country=l.Country, 
City=l.City, 
Address=l.Address
}

devra être:

var result = from loc in Location
where keys.Contains(new {
Country=loc.Country, 
City=loc.City, 
Address=loc.Address
}
select loc;

OriginalL'auteur Chris Snowden

Avez-vous essayé juste en utilisant le n-uplet de classe?

var keys = new[] {
Tuple.Create("Country", "City", "Address"),
…
}
var result = from loc in Location
where keys.Contains(Tuple.Create(loc.Country, loc.City, loc.Address))

OriginalL'auteur sellmeadog

Je ne pense pas que qui va travailler pour vous depuis quand vous êtes newing un objet dans le Contains méthode qu'il va créer un nouvel objet à chaque fois. Puisque ces objets sont anonymes, la façon dont ils seront comparés sont contre leur référence qui sera différent pour chaque objet.

Aussi, regardez Jacek réponse.

OriginalL'auteur Tomas Jansson

je pense que la bonne façon de le faire est

var result = from loc in Location
where loc.Country = _country
where loc.City = _city
where loc.Address = _address
select loc

Il semble unoptimized mais la requête fournisseur de sortir et de faire de l'optimisation quand il transforme la requête sql. Lors de l'utilisation de n-uplets ou d'autres classes, à la requête du fournisseur ne sait pas comment faire pour les transformer en sql et que ce qui cause la NotSupportedException

-edit-

Si vous avez plusieurs tuples je pense que vous avez à boucle à travers eux tous et ne la requête ci-dessus pour chacun d'eux. encore une fois, cela peut sembler underoptimized, mais la requête pour retriving tous les sites dans une seule requête serait probablement jusqu'à la fin étant assez longue:

select * from locations 
where (locations.Country = @country1 and locations.City = @city1, locations.Adress = @adress1)
or (locations.Country = @country2 and locations.City = @city2, locations.Adress = @adress2)
or ...

Le moyen le plus rapide de le faire est probablement de faire les requêtes simples, mais de les envoyer qu'un seul script sql et l'utilisation de plusieurs jeux de résultats pour effectivement obtenir chaque valeur. Je ne suis pas sûr que vous pouvez obtenir EF de le faire bien.

OriginalL'auteur aL3891