Filtrowanie kolekcji z LINQ

Question

Powiedzmy mamy zbiór Osoba obiektów

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

A gdzieś w kodzie zdefiniowano kolekcji

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

Musimy mieć filtr, który trzeba filtrować kolekcję i zwróć wynik użytkownikowi końcowemu. Powiedzmy, że mamy zbiór filtrem typu obiektów

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

A gdzieś w kodzie mamy

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

Więc musimy filtrować zawartości kolekcji personsList przez filtry zdefiniowane w zbiorze userFilters. Gdzie Filter.FieldName == "PersonName" || Filter.FieldName == "PersonAddress". Jak mogę to zrobić z LINQ w fajny sposób? Rozwiązania takie jak switch/case czy mogą być, jak mi się zdawało, metodą rozszerzającą na peopleList, która określa z FiledName właściwość osoby, którą należy zbadać, są znane. Coś innego ? Coś trudnego :) Dziękuję.

Answer 1

Można budować wyrażenia lambda do stworzenia właściwego orzecznik przy użyciu klasy Expression .

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); 
} 

Dzięki tej metodzie pomocnika, można utworzyć metodę rozszerzenia na dowolnej klasy IQueryable<T>, więc to powinno działać na każdym LINQ backend:

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

... co można nazwać tak:

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

Jeśli chcesz wesprzeć IEnumerable<T> kolekcje jak również, musisz skorzystać z tej dodatkowej metody rozszerzenie:

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

Należy zauważyć, że działa to tylko w przypadku właściwości łańcucha. Jeśli chcesz filtrować pola, musisz zmienić Expression.Property w Expression.Field (lub MakeMemberAccess), a jeśli potrzebujesz obsługi innych typów niż właściwości ciągów, będziesz musiał dostarczyć więcej informacji o typie do części Expression.Constant z CreateFilterExpression metoda.

Answer 2

Można to zrobić za pośrednictwem refleksji:

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); 
} 

(nie skompilowane, ale to powinno być po właściwej drodze)

Answer 3

Chciałbym dodać metodę do klasy Filter aby sprawdzić, czy filtr jest spełnione:

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; 
} 

Następnie można go używać tak:

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

Answer 4

nie można po prostu zrobić

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