Помощь с рефакторингом метода LINQ

Question

Мне нужна помощь, у меня есть метод, который повторяется 6 раз в моем классе, и единственное, что изменяется в каждом из методов, это свойство LINQ (в примере " имя, но у меня также есть имя для фамилии, фирменного наименования, идентификатора пользователя, статуса). Я хотел бы получить некоторую помощь рефакторинга это так, что я могу использовать только один метод и сделать свойство быть динамическими или передаются в.

private static IQueryable<MyModel> FilterFirstName(IQueryable<MyModel> query, string searchText, string searchFilter) 
    { 
     switch (searchFilter.ToLower()) 
     { 
      case "contains": 
       query = query.Where(x => x.FirstName.ToLower().Contains(searchText.ToLower())); 
       break; 
      case "does not contain": 
       query = query.Where(x => !x.FirstName.ToLower().Contains(searchText.ToLower())); 
       break; 
      case "starts with": 
       query = query.Where(x => x.FirstName.StartsWith(searchText, StringComparison.InvariantCultureIgnoreCase)); 
       break; 
      case "ends with": 
       query = query.Where(x => x.FirstName.EndsWith(searchText, StringComparison.InvariantCultureIgnoreCase)); 
       break; 
      case "equals": 
       query = query.Where(x => x.FirstName.Equals(searchText, StringComparison.InvariantCultureIgnoreCase)); 
       break; 
     } 

     return query; 
    } 

Answer 1

Что вы можете сделать, это использовать Compose метод, который может составить одно выражение с другим:

public static Expression<Func<TFirstParam, TResult>> 
    Compose<TFirstParam, TIntermediate, TResult>(
    this Expression<Func<TFirstParam, TIntermediate>> first, 
    Expression<Func<TIntermediate, TResult>> second) 
{ 
    var param = Expression.Parameter(typeof(TFirstParam), "param"); 

    var newFirst = first.Body.Replace(first.Parameters[0], param); 
    var newSecond = second.Body.Replace(second.Parameters[0], newFirst); 

    return Expression.Lambda<Func<TFirstParam, TResult>>(newSecond, param); 
} 

который использует следующий метод, чтобы заменить все экземпляры одного выражения с другим:

public static Expression Replace(this Expression expression, 
    Expression searchEx, Expression replaceEx) 
{ 
    return new ReplaceVisitor(searchEx, replaceEx).Visit(expression); 
} 
internal class ReplaceVisitor : ExpressionVisitor 
{ 
    private readonly Expression from, to; 
    public ReplaceVisitor(Expression from, Expression to) 
    { 
     this.from = from; 
     this.to = to; 
    } 
    public override Expression Visit(Expression node) 
    { 
     return node == from ? to : base.Visit(node); 
    } 
} 

Теперь вы можете написать:

private static IQueryable<MyModel> FilterFirstName(
    IQueryable<MyModel> query, 
    Expression<Func<MyModel, string>> selector, 
    string searchText, 
    string searchFilter) 
{ 
    switch (searchFilter.ToLower()) 
    { 
     case "contains": 
      query = query.Where(selector.Compose(
       text => text.ToLower().Contains(searchText.ToLower()))); 
      break; 
     case "does not contain": 
      query = query.Where(selector.Compose(
       text => !text.ToLower().Contains(searchText.ToLower()))); 
      break; 
     case "starts with": 
      query = query.Where(selector.Compose(
       text => text.StartsWith(searchText, StringComparison.InvariantCultureIgnoreCase))); 
      break; 
     case "ends with": 
      query = query.Where(selector.Compose(
       text => text.EndsWith(searchText, StringComparison.InvariantCultureIgnoreCase))); 
      break; 
     case "equals": 
      query = query.Where(selector.Compose(
       text => text.Equals(searchText, StringComparison.InvariantCultureIgnoreCase))); 
      break; 
    } 

    return query; 
} 

На боковой ноте, вы ould действительно используют enum для представления различных типов фильтров для searchFilter, а не для строки. Это сделает его намного проще для вызывающего, так как им не нужно будет вводить точную строку, не имея никакого хорошего способа узнать, что такое точные параметры, или если предоставленный параметр действителен.

Answer 2

Если это называется 6 раз в вашем коде, и есть 5 путей внутри него, Я бы сказал, что сам метод вводит ненужную связь и должен быть удален.

Answer 3

Эта версия позволяет передавать свойство фильтра, например:

Filter(models, (MyModel m) => m.FirstName, "Joe", "contains"); 
Filter(models, (MyModel m) => m.LastName, "Smith", "contains"); 

private static IQueryable<MyModel> Filter(IQueryable<MyModel> query, Func<MyModel, string> property, string searchText, string searchFilter) 
{ 
    switch (searchFilter.ToLower()) 
    { 
     case "contains": 
      query = query.Where(x => property(x).ToLower().Contains(searchText.ToLower())); 
      break; 
     case "does not contain": 
      query = query.Where(x => !property(x).ToLower().Contains(searchText.ToLower())); 
      break; 
     case "starts with": 
      query = query.Where(x => property(x).StartsWith(searchText, StringComparison.InvariantCultureIgnoreCase)); 
      break; 
     case "ends with": 
      query = query.Where(x => property(x).EndsWith(searchText, StringComparison.InvariantCultureIgnoreCase)); 
      break; 
     case "equals": 
      query = query.Where(x => property(x).Equals(searchText, StringComparison.InvariantCultureIgnoreCase)); 
      break; 
    } 

    return query; 
} 

Answer 4

Я хотел бы сделать одно или несколько из следующих действий:

1. Отражения и кэшировать поиск свойства " метод "(бит" x.FirstName "может быть легко обработан с помощью отражения

2. Возьмите функцию« селектор »и ​​примените ее для получения целевого объекта

3. Сделать это метод расширения

Код:

public static class FilterPerson 
{ 
    static IQueryable<Person> FilterPerson(
     this IQueryable<Person> query, 
     FilterString filter, 
     Func<Person, string> selector, 
     string searchText) 
    { 
     var enumerableQuery = query.AsEnumerable(); 
     switch (filter) 
     { 
      case FilterString.Contains: 
       enumerableQuery = enumerableQuery.Where(x => selector(x).ToLowerInvariant().Contains(searchText.ToLowerInvariant())); 
       break; 
      case FilterString.DoesNotContain: 
       enumerableQuery = enumerableQuery.Where(x => !selector(x).ToLower().Contains(searchText.ToLower())); 
       break; 
      case FilterString.StartsWith: 
       enumerableQuery = enumerableQuery.Where(x => selector(x).StartsWith(searchText, StringComparison.InvariantCultureIgnoreCase)); 
       break; 
      case FilterString.EndsWith: 
       enumerableQuery = enumerableQuery.Where(x => selector(x).EndsWith(searchText, StringComparison.InvariantCultureIgnoreCase)); 
       break; 
      case FilterString.Equals: 
       enumerableQuery = enumerableQuery.Where(x => selector(x).Equals(searchText, StringComparison.InvariantCultureIgnoreCase)); 
       break; 
     } 

     return enumerableQuery.AsQueryable(); 
    } 
} 

public class Person 
{ 
    public string FirstName { get; set; } 
    public string LastName { get; set; } 
    public string PhoneNumber { get; set; } 

} 

public enum FilterString 
{ 
    StartsWith, 
    Contains, 
    DoesNotContain, 
    EndsWith, 
    Equals 
}