为过滤器的多个条件创建动态linq表达式OData包含吗？

Question

For a single Contains filter condition in Odata I tried the following:

  var customerData = await myclient.For<Customer>()
            .Filter(x => x.Name.Contains("john"))
            .FindEntriesAsync();

How can I use multiple Contains filters?

For example:

 var customerData = await myclient.For<Customer>()
            .Filter(x => x.Name.Contains("john") || x.Address.Contains("india"))
            .FindEntriesAsync();

I tried with query expression using this code .

But, how do I pass filter expression inside Odata .Filter() ?

List<Filter> filter = new List<Filter>()
{
    new Filter { PropertyName = "City" ,
        Operation = Op .Equals, Value = "Mitrovice"  },
    new Filter { PropertyName = "Name" ,
        Operation = Op .StartsWith, Value = "L"  },
    new Filter { PropertyName = "Salary" ,
        Operation = Op .GreaterThan, Value = 9000.0 }
};

var deleg = ExpressionBuilder.GetExpression<Person>(filter).Compile();

I want to use deleg expression and pass to Odata.

var customerData = await myclient.For<Customer>()
            .Filter(deleg.ToString())
            .FindEntriesAsync();

I'm unable to execute the above statement.

Answer 1

I don't have your datamodel so I used the Northwind OData feed to build a solution for you.

What this does is, iterate over a dictionary, which defines a searchterm and a property in which to look.

We then build a predicate and iterate over each kvp of this. Finally we return a lambda func from this. Think of it as a predicatebuilder in a loop:

/*using http://services.odata.org/V3/Northwind/Northwind.svc/ */

//Define a set of KeyValueParis to search for
var keywords = new Dictionary<string, string> {
    {"Beverages", "CategoryName"}, 
    {"savory", "Description"},
    {"meats", "Description"},
    {"Condiments", "CategoryName"}
};

//Create the predicate and initialize it
Expression<Func<Category, bool>> predicate = x => false;
//Define the type
ParameterExpression parameterExp = Expression.Parameter(typeof(Category), "Category");
//Get the Contains method. reference: http://stackoverflow.com/questions/278684/how-do-i-create-an-expression-tree-to-represent-string-containsterm-in-c
MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });

//Iterate over each kvp
foreach (var kvp in keywords)
{
    var body = predicate.Body;
    //set the property or field we are checking against
    var memberExpr = Expression.PropertyOrField(parameterExp, kvp.Value);
    var constExpr = Expression.Constant(kvp.Key, typeof(string));
    var containsMethodExpr = Expression.Call(memberExpr, method, constExpr);

    body = Expression.OrElse(body, containsMethodExpr);

    predicate = Expression.Lambda<Func<Category, bool>>(body, parameterExp);
}

Categories.Where (predicate).Dump();

Ouput:

The only thing left for your to do is replace the Category against your target type. If time allows it, I'll wrap this in a generic method and add it to this answer.

Linqpad source

//EDIT: Heres a static method to build your expression. You only need to provde a Dictionary<string,string> witht he search terms.

static Expression<Func<T, bool>> BuildExpression<T>(Dictionary<string, string> searchTerms)
{
    //Create the predicate and initialize it
    Expression<Func<T, bool>> predicate = x => false;
    //Define the type
    ParameterExpression parameterExp = Expression.Parameter(typeof(T), "type");
    //Get the Contains method. reference: http://stackoverflow.com/questions/278684/how-do-i-create-an-expression-tree-to-represent-string-containsterm-in-c
    MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) });

    //Iterate over each kvp
    foreach (var kvp in searchTerms)
    {
        var body = predicate.Body;
        //set the property or field we are checking against
        var memberExpr = Expression.PropertyOrField(parameterExp, kvp.Value);
        var constExpr = Expression.Constant(kvp.Key, typeof(string));
        var containsMethodExpr = Expression.Call(memberExpr, method, constExpr);

        body = Expression.OrElse(body, containsMethodExpr);

        predicate = Expression.Lambda<Func<T, bool>>(body, parameterExp);
    }
    return predicate;
}

Usage:

var lambda = BuildExpression<Category>(keywords);
Categories.Where(lambda).Dump();

Answer 2

First, Simple.OData.Client has its own LINQ expression parser, so everything that comes to Filter clause is sent to its custom parser that is far more limited than the one built into C# (aka LINQ-to-objects). And it's limited for good reasons, because it can't provide more than provided by OData protocol.

So expressions like Filter deleg.ToString() will not work, you will have to write the explicit expression.

Second, you can stack multiple Filter clauses but they will be combined using "AND" operator. And you need "OR".

Third, the expression that you wrote (x => x.Name.Contains("john") || x.Address.Contains("india")) is a supported expression and should work.

If you must incrementally build Filter clause from a set of expressions then the only way to achive it using current version of Simple.OData.Client is to send a string to Filter, and that string can be built incrementally. You can even generate individual parts using Simple.OData.Client method GetCommandTextAsync() , then extract filter parts from them and concatenate. I know, it's not elegant.

UPDATE: I just pushed the version 4.12 that exposes public constructor for ODataExpression. So you can do things like these:

Expression<Predicate<Product>> condition1 = x => x.ProductName == "Chai";
Expression<Func<Product, bool>> condition2 = x => x.ProductID == 1;
var filter = new ODataExpression(condition1);
filter = filter || new ODataExpression(condition2);
var result = await client.For<Product>.Filter(filter).FindEntriesAsync();

or

var filter = new ODataExpression<Product>(x => x.ProductName == "Chai");
filter = filter || new ODataExpression<Product>(x => x.ProductID == 1);
var result = await client.For<Product>.Filter(filter).FindEntriesAsync();