是否可以转换表达式 <Func<T, bool> &gt;表达 <Func<MyType, bool> &gt;？

Question

I have a repository class with some generic methods. One is

public IEnumerable<T> FindAll<T>(Expression<Func<T, bool>> predicate) where T : class
{
    return GetDbSet<T>().Where(predicate);
}

For unit testing I have a TestRepository which uses in-memory objects instead of a database. The TestRepository overrides the FindAll method and I want to control what is returned. So I want to be able to do something like this:

public override IEnumerable<T> FindAll<T>(Expression<Func<T, bool>> predicate)
{
    return MyEntities.Where(predicate).Cast<T>();
}

But MyEntities.Where() only accepts a Expression<Func<MyEntity, bool>> .

How can I cast/convert the generic expression to the strongly typed expression?

Answer 1

You can do something like this. Not sure whether it's a good idea, but it works. Basically, your overload can compare the type parameter T to your entity class. If the predicate has the right type, you can cast. Otherwise, you don't have anything to return.

public class MyEntity { public int x; }

MyEntity[] MyEntitiesList = Enumerable.Range(1,5).Select(y => new MyEntity() { x = y }).ToArray();

public IEnumerable<T> FindAll<T>(Expression<Func<T, bool>> predicate)
{
     if (typeof(T) == typeof(MyEntity))
     {
         return (IEnumerable<T>)MyEntitiesList.Where((predicate as Expression<Func<MyEntity, bool>>).Compile());
     }
     return new T[0];
}

---

Usage:

var res = FindAll((MyEntity y) => y.x % 2 == 0).ToList();
Console.WriteLine(res.Count);

Answer 2

It looks like your repository implementation has a major flaw in a sense that the caller is not aware that he can only pass arguments of certain types (eg it looks like I can do FindAll<int>(v => v > 0) but in fact, the underlying implementation only works with MyEntity ). In other words, it's trying to be too "smart", it's not intuitive and error-prone.

One way of fixing this can be by introducing an interface/base class:

public interface IRepository<T>
{
  IEnumerable<T> FindAll<T>(Expression<Func<T, bool>> predicate);
}

// A base class that can carry helper functionality.
public abstract class Repository<T> : IRepository<T>
{
  private readonly IEnumerable<T> _entities;

  protected Repository(IEnumerable<T> entities)
  {
    _entities = entities;
  }

  public IEnumerable<T> FindAll(Expression<Func<T, bool>> predicate)
  {
    return _entities.Where(predicate);
  }
}

// Concrete implementation
public class MyEntityRepository : Repository<MyEntity>
{
  public MyEntityRepository() : base(new MyDbContext().MyEntities) { }
}

In the above example I'm referring to MyDbContext just for demonstration purposes (so it looks a bit more familiar if you worked with Entity Framework ).

Now you can instantiate MyEntityRepository and use it throughout the application. In case you're using some sort of IoC, you can modify the code slightly:

public interface IMyEntityRepository : IRepository<MyEntity>
{
  // ...
}

public class MyEntityRepository : Repository<MyEntity>, IMyEntityRepository
{
  // ...
}

And now you can easily inject and mock IMyEntityRepository within your application.

Hope this helps.

UPDATE

As it turns out, since the given implementation is used for testing purposes only, you could try producing the expression of a desired type the following way:

return MyEntities.Where(Expression.Lambda<Func<MyEntity, bool>>(predicate.Body, 
  predicate.Parameters)).Cast<T>();

You can also apply some casting to the lambda parameter, if explicit one is needed.