Let\'s say we have a collection of Person objects
class Person
{
public string PersonName {get;set;}
public string PersonAddress {get;set;}
}
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)));
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.
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)
Can't you just do
personList.Where(x => x.PersonName == "YourNameHere").ToList() ?