Entidad marco dinámico donde Cláusula

Question

tengo una consulta como:

var function = GetSomeExpression();  

using (FooModel context = new FooModel()) 
{ 
    var bar = context.Bar.Where(function); 
} 

Me gustaría hacer un método genérico que puede ejecutar Dónde contra diferentes entidades en el contexto. El objetivo es no tener que hacer context.Bar.Where, context.Car.Where, Context.Far.Where, etc.

Algo que no se puede hacer, pero ilustra el objetivo es:

var q = context.GetObjectContext(T).Where(queryFunction); 

He analizado el uso de Relfection y puedo obtener el método Where, pero no sé cómo ejecutarlo en el contexto que pasa en el delegado. También miré DynamicMethod, pero hacer todo el trabajo de IL no me gusta.

Lo que tengo hasta ahora:

private List<T> GetResults<T>(Expression<Func<T, bool>> queryFunction) 
{ 
    // note: first() is for prototype, should compare param type 
    MethodInfo whereMethod = typeof(Queryable).GetMethods() 
     .Where(m => m.Name == "Where") 
     .First().MakeGenericMethod(typeof(T)); 

    // invoke the method and return the results 
    List<T> result = whereMethod.Invoke(
    // have the method info 
    // have the expression 
    // can reference the context 
    ); 

    throw new NotImplementedException(); 
} 

Es esto posible hacerlo?

Answer 1

Ésta es la manera más fácil que lo que estaba tratando antes:

private List<T> GetResults<T>(IQueryable<T> source, 
    Expression<Func<T, bool>> queryFunction) 
{ 
    return source.Where(queryFunction).ToList<T>(); 
} 

Answer 2

ver este post

LINQ to entities - Building where clauses to test collections within a many to many relationship

Editar: después de la actualización posterior a esto no parece más pertinente; Lo dejaré en caso de que sea útil.