CODEWITHSUNDEEP
c#.netlinq
Tigran
Tigran

Reputation: 62265

Filtering collection with LINQ

Let's say we have a collection of Person objects 

class Person 
{
     public string PersonName {get;set;}
     public string PersonAddress {get;set;}    
}

And somewhere in the code defined collection 

List<Person> pesonsList = new List<Person>();

We need to have a filter that need to filter the collection and return the result to the end user. Let's say we have a collection of Filter type objects

class Filter 
{
    public string FieldName {get;set;}
    public string FilterString {get;set;}
}

And somewhere in the code we have 

List<Filter> userFilters = new List<Filter>();

So we need to filter the content of the personsList collection by filters defined in the userFilters collection. Where the Filter.FieldName == "PersonName" || Filter.FieldName == "PersonAddress". How can I do that with LINQ in a cool way ? The solutions like switch/case, or may be, I thought, extension method on personsList that determines from the FiledName the property of the Person to look into, are known. Something else ? Something tricky:) Thank you.

Upvotes: 10

Views: 16694

Answers (4)

ThatGuy
ThatGuy

Reputation:

Can't you just do 

personList.Where(x => x.PersonName == "YourNameHere").ToList() ?

Upvotes: 2

Ruben
Ruben

Reputation: 15555

You can build a lambda expression to create a proper predicate using the Expression class.

public static Expression<Func<TInput, bool>> CreateFilterExpression<TInput>(
                                                   IEnumerable<Filter> filters)
{
    ParameterExpression param = Expression.Parameter(typeof(TInput), "");
    Expression lambdaBody = null;
    if (filters != null)
    {
        foreach (Filter filter in filters)
        {
            Expression compareExpression = Expression.Equal(
                    Expression.Property(param, filter.FieldName),
                    Expression.Constant(filter.FilterString));
            if (lambdaBody == null)
                lambdaBody = compareExpression;
            else
                lambdaBody = Expression.Or(lambdaBody, compareExpression);
        }
    }
    if (lambdaBody == null)
        return Expression.Lambda<Func<TInput, bool>>(Expression.Constant(false));
    else
        return Expression.Lambda<Func<TInput, bool>>(lambdaBody, param);
}

With this helper method, you can create an extension method on any IQueryable<T> class, so this should work for every LINQ backend:

public static IQueryable<T> Where<T>(this IQueryable<T> source, 
                                          IEnumerable<Filter> filters)
{
    return Queryable.Where(source, CreateFilterExpression<T>(filters));
}

...which you can call like this:

var query = context.Persons.Where(userFilters);

If you want to support IEnumerable<T> collections as well, you'll need to use this extra extension method:

public static IEnumerable<T> Where<T>(this IEnumerable<T> source, 
                                           IEnumerable<Filter> filters)
{
    return Enumerable.Where(source, CreateFilterExpression<T>(filters).Compile());
}

Note that this only works for string properties. If you want to filter on fields, you'll need to change Expression.Property into Expression.Field (or MakeMemberAccess), and if you need to support other types than string properties, you'll have to provide more type information to the Expression.Constant part of the CreateFilterExpression method.

Upvotes: 10

Bojan Resnik
Bojan Resnik

Reputation: 7388

I would add a method to the Filter class to check if the filter is satisfied:

class Filter 
{
    public string FieldName {get;set;}
    public string FilterString {get;set;}

    public bool IsSatisfied(object o)
    { return o.GetType().GetProperty(FieldName).GetValue(o, null) as string == FilterString;
}

You can then use it like this:

var filtered_list = personsList.Where(p => userFilters.Any(f => f.IsSatisfied(p)));

Upvotes: 0

kevingessner
kevingessner

Reputation: 18995

You can do it via reflection:

IQueryable<Person> filteredPersons = personsList.AsQueryable();
Type personType = typeof(Person);
foreach(Filter filter in userFilters) {
    filteredPersons = filteredPersons.Where(p => (string)personType.InvokeMember(filter.FieldName, BindingFlags.GetProperty, null, p, null) == filter.FilterString);
}

(not compiled, but this should be along the right track)

Upvotes: 3

Related Questions