Extension with property selector

Hi guys!

I have the problem with writing LINQ extension method with LightSpeed entities collection. Assume we have the following model:

And I want to have an extension method for IQueryable that would filter my entities (Merchants, Terminals, MerchantRequests, etc.) by the branch. Something like this:

var merchants = unitOfWork.MerchantDbModels.BranchFilter(x => x.AcquirerContract.Branch.Id);
var terminals = unitOfWork.TerminalDbModels.BranchFilter(x => x.Merchant.AcquirerContract.Branch.Id);

And so on, just to specify property selector for the field containing branch ID. So, I've written this:

public static IQueryable<T> BranchFilter(this IQueryable<T> source, Func<T, int> branchIdPropertySelector)
{
    var userBranchIds = new List<int>();
    /* some code to get branch IDs for user */
    return source.Where(x => userBranchIds.Contains(branchIdPropertySelector(x)));
}

But here I'm getting "This expression type is not supported in LightSpeed 4.0" error. Note, that I'm using LS 5.0 from 03/23/2015 nightly. Why it tells me that it's not supported in LS 4.0?) I believe it's just an old value in error message string and can be changed too.

But the main question is how can I reach my goal? Is it possible to have such operations in the LightSpeed LINQ?

OMG, I've forgotten that I asked it already)

http://www.mindscapehq.com/forums/thread/2177242

But it's still make me pain - why can't it be implemented from your side? You need just to implement support for property selectors (Func) in your classes for Expressions and tries in LS LINQ project and that would significantly increase happiness of using LS LINQ!

OK. I'm trying to reach this from other side. The model is the same.

Lets write an interface highlighting Branch ID field:

public interface IBranchable
{
    Int32 BranchId { get; }
}

And let's implement it for the partial db model class:

public partial class MerchantRequestDbModel : IBranchable
{
    public int BranchId
    {
        get { return AcquirerContract.BranchId; }
    }
}

And let's write the following extension for the IQuaryable collection:

public static IQueryable<T> BranchFilter<T>(this IQueryable<T> source) where T : IBranchable
{
    var ids = AltairBranchHelper.UserBranchIds;
    return source.Where(x => ids.Contains(x.BranchId));
}

But this code still failed with an error:

var hasRequests = unitOfWork.MerchantRequestDbModels.BranchFilter().Any();

And here is the stack trace:

[ArgumentNullException: argument cannot be null.
Parameter name: entityType]
   Mindscape.LightSpeed.Querying.PathExpression..ctor(Type entityType, String path) +128
   Mindscape.LightSpeed.Linq.Translations.CollectionContainsBase.Apply(QueryExpression applyTo, DataProvider provider, QueryExpression[] arguments) +562
   Mindscape.LightSpeed.Linq.Sqo.CriteriaSqo.ExtractMethodCriteria(LinqQueryPlanExpression plan, MethodCallExpression expression) +279
   Mindscape.LightSpeed.Linq.Sqo.CriteriaSqo.ExtractCriteriaCore(LinqQueryPlanExpression plan, Expression expression) +355
   Mindscape.LightSpeed.Linq.Sqo.CriteriaSqo.ExtractCriteria(LinqQueryPlanExpression plan, Expression expression) +59
   Mindscape.LightSpeed.Linq.Sqo.CriteriaSqo.ExtractCriteriaCore(LinqQueryPlanExpression plan, Expression expression) +173
   Mindscape.LightSpeed.Linq.Sqo.CriteriaSqo.ExtractCriteria(LinqQueryPlanExpression plan, Expression expression) +59
   Mindscape.LightSpeed.Linq.Sqo.CriteriaSqo.ExtractCriteriaCore(LinqQueryPlanExpression plan, Expression expression) +313
   Mindscape.LightSpeed.Linq.Sqo.CriteriaSqo.ExtractCriteria(LinqQueryPlanExpression plan, Expression expression) +59
   Mindscape.LightSpeed.Linq.Sqo.Where.ExtractWhereCriteria(MethodCallExpression expression, LinqQueryPlanExpression plan, GroupResultsPlan groupPlan) +63
   Mindscape.LightSpeed.Linq.Sqo.Where.Evaluate(ExpressionVisitor visitor, MethodCallExpression expression) +925
   Mindscape.LightSpeed.Linq.Plan.LinqQueryBuilder.VisitMethodCall(MethodCallExpression exp) +1150
   Mindscape.LightSpeed.Linq.Plan.LinqQueryBuilder.Visit(Expression exp) +146
   Mindscape.LightSpeed.Linq.Sqo.CountBase.Evaluate(ExpressionVisitor visitor, MethodCallExpression expression) +62
   Mindscape.LightSpeed.Linq.Plan.LinqQueryBuilder.VisitMethodCall(MethodCallExpression exp) +989
   Mindscape.LightSpeed.Linq.Plan.LinqQueryBuilder.Visit(Expression exp) +146
   Mindscape.LightSpeed.Linq.LinqQueryProvider.GetExecutionPlan(Expression expression) +167
   Mindscape.LightSpeed.Linq.LinqQueryProvider.Execute(Expression expression) +38
   Mindscape.LightSpeed.Linq.LinqQueryProvider.System.Linq.IQueryProvider.Execute(Expression expression) +5
   System.Linq.Queryable.Count(IQueryable`1 source) +233

Is it possible to make this kind of solution make work? Any thoughts? Thanks in advance!

Without the project to reproduce this the use of this client side code stands out as possibly being the issue:

var ids = AltairBranchHelper.UserBranchIds;

What does that property do?

Jeremy

It's just getting a List of Int32 containing available Branch IDs for current user. I've created an example project with three my attempts of such filter implementation and all failed:

• just LINQ
• combining filter from Expessions
• IBranchable interface

Could you please help me to reach my final goal? I want to have an extension method filtering my entities by branch (i.e. get only those terminals, merchants, etc which belongs to the branches only available for user).

Thanks for the repro project. The issue is due to trying to translate the predicate passed to your BranchFilter method as it is seen as a method invocation which we dont support.

Did you try:

uow.TerminalDbModels.Where(x => BranchHelper.UserBranchIds.Contains(x.Merchant.AcquirerContract.BranchId)).ToList();

to cover the initial query?

Jeremy

Thanks for your reply. Yes, I've already tried the code you recommended. It works but looks unpleasant. =)

I finally managed to find a working solution. Here is it:

public static IQueryable<T> BranchFilter<T>(this IQueryable<T> source, Expression<Func<T, int>> branchIdPropertySelector)
{
    var branchIdList = Expression.Constant(AltairBranchHelper.UserBranchIds);

    var exp =
        Expression.Lambda<Func<T, bool>>(
            Expression.Call(branchIdList, typeof(List<int>).GetMethod("Contains"),
                branchIdPropertySelector.Body), branchIdPropertySelector.Parameters);

   return source.Where(exp);
}

The key moment was in proper combining two lambdas into one. I was wrong trying to do it with Expression.Invoke method. The right way was in using the Body of property selector (as it shown in the code).

But for the future you may implement ExpressionType.Invoke in your linq provider. for example you may evaluate it as a subquery and use this result in the main query.