Using Reflection to invoke a FindBy method that takes an Expression on an Repository

Question

So I have a method that I need to get a collection of Repositories from my Bucket, loop through those repositories and find all the records in the repository that need to be expired and then expire them. I am having a problem figuring out how to execute a Invoke using a Func. Any thoughts? Am I going down the wrong path?

    public void DeactivateNonTransversableExpiredRecords()
    {
        databucket = new AdminBucket(PublishingFactory.AuthoringContext);

        IEnumerable<Tuple<dynamic, Type>> nonTransversableList = this.GetNonTransversableRepositories(databucket);

        foreach (Tuple<dynamic, Type> repository in nonTransversableList)
        {
            Type repoType = repository.Item1.GetType(); // RepositoryType
            var method = repoType.GetMethod("FindBy"); // Method
            var entityType = repository.Item2; // EntityType

            // Not working
            IQueryable recordsToExpire = method.Invoke(new Func<BaseEntity, bool>((x) => x.IsActive));

            foreach (var row in recordsToExpire)
            {
                ((BaseEntity) row).IsActive = false;
                repository.Item1.Edit((BaseEntity) row);
            }
        }
    }`

EDIT: Solution... the contribution from @Eduard was invaluable in solving this challenge. I will up vote his contribution however, it was not the actual solution that was implemented.

Through the contributed code I found that returning a IQueryable to a dynamic variable like I was doing caused problems when trying to save records back to the database. If you are going for a Read only set then @Eduard's solution will work elegantly.

I ended up creating a publication specific method in the Model's BaseRepository that calls the .FindBy() method in the same Repository. This publication specific method returns a IList<T> to the publication application. This allows the dynamic variable to work properly when enumerating the collection and executing an .Edit() without having to worry about what Types go to what repository. Using the default .FindBy() returned a IQueryable<T> which caused EF5 to puke saying 'a new transaction is not allowed because there are other threads running in the session'.

Here is a working sample

Model's BaseRepository Code

public IList<T> GetItemsToExpire(DateTime date)
{
    return this.GetActive(x => x.ExpirationDate <= date).ToList<T>();
}

public virtual IQueryable<T> GetActive(Expression<Func<T, bool>> predicate)
{
    return this.GetActive().Where(predicate);
}

public virtual new IQueryable<T> GetActive()
{
    return this.FindBy(entity => entity.IsActive)
}

Publication Service Code

public void DeactivateNonTransversableExpiredRecords()
{
    databucket = new AdminBucket(PublishingFactory.AuthoringContext);

    IEnumerable<dynamic> nonTransversableRepositories = this.GetNonTransversableRepositories(databucket);

    foreach (dynamic repository in nonTransversableRepositories)
    {
        dynamic activeRecordsReadyToExpire = repository.GetItemsToExpire(DateTime.Now.AddDays(-1));  
        foreach (var record in activeRecordsReadyToExpire)
        {
            ((BaseEntity)record).IsActive = false;
            repository.Edit(record, true);
        }
    }
}

Answer 1

I'm gonna make an assumption based on my intuition and say that I see 2 problems in your code.

1st of all, your FindBy method is most surely an instance method, not a static method. So apart from the parameter you're willing to pass it (the Func) you also need to pass it the instance on which the "FindBy" method should be called on. Plus: You need to thoroughly respect the Invoke method's signature: one object for the instance, one array of objects for the parameters.

2ndly, you would probably be just fine with using the DLR and syntactically invoke the hoped for method.

Please note my minor modification:

        Type repoType = repository.Item1.GetType(); // RepositoryType
        var method = repoType.GetMethod("FindBy"); // Method
        var entityType = repository.Item2; // EntityType

        // Should work
        IQueryable recordsToExpire = method.Invoke(
             repository.Item1, 
             new object[] { (Expression<Func<BaseEntity, bool>>)((x) => x.IsActive) }
        ) as IQueryable;

If you'll have a look at the Invoke method of the MethodInfo class you'll notice that the 1st parameter is the "this" parameter. So what you were doing was trying to invoke "FindBy" on the Func < T, ReturnType > delegate type (which does not have a method called "FindBy")

A more aesthetical approach would be to just go with the flow, use the DLR, use the power of the "dynamic" type, something like so:

        //Type repoType = repository.Item1.GetType(); // RepositoryType
        //var method = repoType.GetMethod("FindBy"); // Method
        var entityType = repository.Item2; // EntityType

        // Should work
        dynamic someDynamicResult = repository.Item1.FindBy ((Expression<Func<BaseEntity, bool>>)((x) => x.IsActive));
        IQueryable whichAtRuntimeShouldActuallyBeAnIQueryable = someDynamicResult;

BIG EDIT

Should you need to dynamically create explicit "IsActive" lambdas, you could do it like so:

public class SomeClass
{
    private static MethodInfo methodOf_CreateLambdaGeneric = 
        typeof(SomeClass).GetMethod("CreateIsActiveLambdaGeneric");

    public static Expression<Func<T, bool>> CreateIsActiveLambdaGeneric<T>() where T : BaseEntity {
        return x => x.IsActive;
    }
    public static LambdaExpression CreateIsActiveLambda(Type type) {
        MethodInfo particularized = methodOf_CreateLambdaGeneric.MakeGenericMethod(type);
        object theLambda = particularized.Invoke(null, null);
        return theLambda as LambdaExpression;
    }
    }

and then use those helper methods like so:

        //Type repoType = repository.Item1.GetType(); // RepositoryType
        //var method = repoType.GetMethod("FindBy"); // Method
        var entityType = repository.Item2; // EntityType

        // Should work
        LambdaExpression compatibleIsActiveLambda = SomeClass.CreateIsActiveLambda(entityType);
        dynamic someDynamicResult = repository.Item1.FindBy (compatibleIsActiveLambda as dynamic);
        IQueryable whichAtRuntimeShouldActuallyBeAnIQueryable = someDynamicResult;

Answer 2

FindBy is expecting an Expression<Func<TEntity, bool>> you're giving it a Func<TEntity, bool>

Have you tried dropping the Func< piece and just doing method.Invoke((x) => x.IsActive)?

Answer 3

See solution in the Question for what worked in my situation. Also if you are not worrying about writing back to the database then @EduardDumitru solution will work great.