LINQ: pasando la expresión lambda como parámetro para ser ejecutado y devuelto por el método

Question

Así que aquí está el escenario: tengo una serie de diferentes clases de repositorio que pueden usar un contexto de datos aislado o un contexto compartido. En los casos en que se utiliza un contexto aislado, quiero agregar un método a la clase base que me permita especificar el lambda como parámetro, hacer que esa expresión sea ejecutada por el contexto aislado del repositorio elegido y devolver un resultado IQueryable . ¿Cómo se vería la firma del método y cómo pasar la expresión al contexto?

Necesito que la solución sea lo más genérica posible ya que podría usarse cualquier objeto/tabla posible.

Aquí es básicamente lo que estoy buscando hacer:

IAssetRepository repo = new AssetRepository(true); // true indicates isolated context 
var results = repo.ExecuteInContext<SomeType>(SomeTable.Where(x => 
               x.SomeProp.Equals(SomeValue))); 

Answer 1

Algo como esto:

public IEnumerable<T> ExecuteInContext<T>(
    Expression<Func<T,bool>> predicate) 
{ 
    ... // do your stuff 
    //eg 
    Table<T> t = GetTable<T>(); 
    return t.Where(predicate); 
} 

o

public IEnumerable<T> ExecuteInContext<T>(
    IQueryable<T> src, Expression<Func<T,bool>> predicate) 
{ 
    return src.Where(predicate); 
} 

Uso:

var r = repo.ExecuteInContext<SomeType>( 
      x => x.SomeProp.Equals(Somevalue)); 

o

var r = repo.ExecuteInContext(GetTable<T>(), 
      x => x.SomeProp.Equals(Somevalue)); 

Supuestos:

1. tabla se puede derivar a partir de T, de lo contrario tendrán que pasar la fuente también.
2. Ya sabe cómo modificar la expresión del predicado si es necesario.

Answer 2

Salida PredicateBuilder - http://www.albahari.com/nutshell/predicatebuilder.aspx

Este código empaquetar su cláusula where como objetos de expresión que se pueden pasar alrededor.

Implementé el patrón Repositorio, y mi flava es para darle un método Fetch (ICriteria), que construye la cláusula Where dependiendo de los criterios suministrados. Simple, pero funciona para mi

Answer 3

Aquí es una muestra completa de trabajo cómo pasar expresión LINQ como parámetro

using System; 
using System.Linq.Expressions; 
using System.Reflection; 

namespace ConsoleTest 
{ 
    public class Values 
    { 
     public int X { get; set; } 
     public int Y { get; set; } 

     public override string ToString() 
     { 
      return String.Format("[ X={0} Y={1} ]", X, Y); 
     } 
    } 

    class Program 
    { 
     static void Main() 
     { 
      var values = new Values {X = 1, Y = 1}; 

      // pass parameter to be incremented as linq expression 
      IncrementValue(values, v => v.X); 
      IncrementValue(values, v => v.X); 
      IncrementValue(values, v => v.Y); 

      // Output is: [ X=3 Y=2 ] 
      Console.Write(values); 
     } 

     private static void IncrementValue<T>(T obj, Expression<Func<T,int>> property) 
     { 
      var memberExpression = (MemberExpression)property.Body; 
      var propertyInfo = (PropertyInfo)memberExpression.Member; 
      // read value with reflection 
      var value = (int)propertyInfo.GetValue(obj, null); 
      // set value with reflection 
      propertyInfo.SetValue(obj, ++value, null); 
     } 
    } 
}