Discussion :

[davcha]

Deux classes, Entry et Category, partagent une relation many-to-many.

Je cherche à réaliser un moteur de recherche permettant, notamment, de rechercher toutes les Entry qui apparaissent dans une des catégories d'une liste de catégories.

J'ai donc fait ceci :

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
var result = ..... Toutes les Entries de ma base....;
var categories = .... On récupère la liste des catégories...;
if(categories.Count() > 0){
  results = from r in results
    where r.Categories.Any(c => categories.Contains(c))
    select r;
}

Et j'ai cette erreur :

System.NotSupportedException was unhandled
Message="The specified type member 'Categories' is not supported in LINQ to Entities. Only initializers, entity members, and entity navigation properties are supported."
Source="System.Data.Entity"
StackTrace:
à System.Data.Objects.ELinq.ExpressionConverter.MemberAccessTranslator.TypedTranslate(ExpressionConverter parent, MemberExpression linq)
à System.Data.Objects.ELinq.ExpressionConverter.TypedTranslator`1.Translate(ExpressionConverter parent, Expression linq)
à System.Data.Objects.ELinq.ExpressionConverter.TranslateExpression(Expression linq)
.... blablabla....

Des idées ?

[davcha]

J'ai trouvé, en fait, ça vient du fait que la propriété Categories n'est pas une propriété de navigation, mais une propriété ajoutée à la main.

En effet, Entry dérive en Contact et Organisation. Et ce sont Contact et Organisation qui disposent de la propriété de navigation Categories....

Par contre, c'est pas réglé pour autant, en se branchant sur Contact ou Organisation, j'obtiens une erreur au niveau de la méthode "Contains" que EF ne semble pas supporter.....

[davcha]

EF ne supporte pas les choses comme :

var list = new int{1,2,3,4};
var result = context.Entities.Where(e=>list.Contains(e));

[anthyme]

euhhh comment une entité pourrait être un int ?

[davcha]

Erreur d'inattention, désolé ^^
Je voulais dire :

var list = context.Entities.Where(e=>list.Contains(e.ID));

Ceci dit, dans mon cas, il s'agit bien d'entitées :
var categories = ... une sélection de catégories;
var list = context.Entries.Where(e=>e.Categories.Any(c=>categories.Contains(c)));

Mais ça ne change rien au problème : ce que ne gère pas EF, ce sont les listes d'objets externes au modèle. Que ces objets soient des types primitifs, des structs, des classes, ou des entités, ça n'a pas d'importance.

[davcha]

J'ai trouvé ceci pour transformer une expression Set.Contains en un équivalent utilisable par EF.

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
static Expression<Func<TElement, bool>> BuildContainsExpression<TElement, TValue>(
	Expression<Func<TElement, TValue>> valueSelector,
	IEnumerable<TValue> values)
{
	if ( null == valueSelector ) { throw new ArgumentNullException("valueSelector"); }
	if ( null == values ) { throw new ArgumentNullException("values"); }
	ParameterExpression p = valueSelector.Parameters.Single();
	if ( !values.Any() ) {
		return e => false;
	}
	var equals = values.Select(value => ( Expression )Expression.Equal(valueSelector.Body, Expression.Constant(value, typeof(TValue))));
	var body = equals.Aggregate<Expression>((accumulate, equal) => Expression.Or(accumulate, equal));
	return Expression.Lambda<Func<TElement, bool>>(body, p);
}

Petite particularité dans mon cas, néanmoins :

Ceci ne marchera pas :

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
var filter = BuildContainsExpression<Category, Guid>(c=>c.ID, categories.Select(c=>c.ID));
var results = context.Entities.Where(e=>e.Categories.Any(filter));

Alors que ceci fonctionnera :

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
var filter = BuildContainsExpression<Category, Guid>(c=>c.ID, categories.Select(c=>c.ID));
var results = context.Entities.Where(e=>e.Categories.AsQueryable().Any(filter));

Hé oui, sinon, on tape dans les méthodes d'extension de IEnumerable.