重用包含相同屬性但不同lambda where子句條件的方法

Question

這是示例場景，我有3種不同的方法，不同的參數，但結果是屬性類的返回列表相同。

這是我的代碼：

// My Model class:
public class Users{ 
   public string Name{ get; set; }
   public int Age { get; set; }
   public string Location { get; set; }
}

// My Vm class:
public class UserVm { 
   public string Name{ get; set; }
   public int Age { get; set; }
   public string Location { get; set; }
}

這是我的lambda查詢

// by name
public IEnumerable<UserVm> GetUsersByName (string name){
      return db.Users.Where(x=>x.Name == name).Select(users=>new UserVm{
          Name = users.Name,
          Age = users.Age,
          Location = users.Location
      }).Tolist();
}

// by location
public IEnumerable<UserVm> GetUsersByAge (int age){
      return db.Users.Where(x=>x.Age == age).Select(users=>new UserVm{
          Name = users.Name,
          Age = users.Age,
          Location = users.Location
      }).Tolist();
}

// by age
public IEnumerable<UserVm> GetUsersByLocation (string location){
      return db.Users.Where(x=>x.Location== location).Select(users=>new UserVm{
          Name = users.Name,
          Age = users.Age,
          Location = users.Location
      }).Tolist();
}

正如您所注意到的，它們都在視圖模型中返回相同的結果。 有沒有像我可以重用那些冗余代碼的方法？ 就像我會把這些代碼

return db.Users.Where(x=>x.Location== location).Select(users=>new Users{
          Name = users.Name,
          Age = users.Age,
          Location = users.Location
      }).Tolist();

在一個方法中，但是它們的where子句在調用main方法的每個方法中都不同？

Answer 1

只需將lambda表達式作為Func<Users, bool>傳遞給您的查詢：

public IEnumerable<UserVm> GetUsers(Func<Users, bool> predicate)
{
      return db.Users.Where(predicate).Select(users=>new UserVm
      {
          Name = users.Name,
          Age = users.Age,
          Location = users.Location
      });
}

另請注意，我已從原始代碼中刪除了ToList() ，因為無論如何您都要返回IEnumerable 。

你這樣使用它：

// To get all users under a specific age
var usersVm = GetUsers(u => u.Age < age);

// To get all users with a specific name
var usersVm = GetUsers(u => u.name == name);

順便說一句：我喜歡在ViewModel類中有一個構造函數，它是一個Model類的實例，所以我可能會這樣寫：

public class UserVm { 
   public UserVm (Users model)
   {
       Name = model.Name;
       Age = model.Age;
       Location = model.Location;
   }
   public string Name{ get; set; }
   public int Age { get; set; }
   public string Location { get; set; }
}

然后你的GetUsers方法看起來像這樣：

public IEnumerable<UserVm> GetUsers(Func<Users, bool> predicate)
{
      return db.Users.Where(predicate).Select(user => 
          new UserVm(user));
}

Answer 2

您可以做的一件簡單的事情是在Extension方法中移動UserVm對象，並且不再重復對象初始化。

public static class UsersExtensionMethods
{
    public static UserVm ToVm(this User user)
    {
        return new UserVm
        {
            Name = user.Name,
            Age = user.Age,
            Location = user.Location
        };
    }
}

// by name
public IEnumerable<UserVm> GetUsersByName (string name){
      return db.Users.Where(x=>x.Name == name).Select(u => u.ToVm()).Tolist();
}

// by age
public IEnumerable<UserVm> GetUsersByAge (int age){
      return db.Users.Where(x=>x.Age == age).Select(u => u.ToVm()).Tolist();
}

// by age
public IEnumerable<UserVm> GetUsersByLocation (string location){
      return db.Users.Where(x=>x.Location== location).Select(u => u.ToVm()).Tolist();
}

Answer 3

創建一個新方法：

public List<Users> GetUsers(object vmData)
{
   vmData.Select(users=>new Users{
          Name = users.Name,
          Age = users.Age,
          Location = users.Location
      }).Tolist();
}

Answer 4

您可以為過濾制作不同的擴展方法。

public static IEnumerable<UserVm> FilterByName(this IEnumerable<UserVm> query, string name)
{
    return query.Where(x => x.Name == name);
}

並轉換為Users對象：

public static IEnumerable<Users> ToUsers(this IEnumerable<UserVm> query)
{
    return query.Select(users => new Users{
        Name = users.Name,
        Age = users.Age, 
        Location = users.Location
    });
}

這允許你這樣稱呼它：

var usersA = db.Users.FilterByName("A").ToUsers().ToList();

這個例子可以在這個小提琴中找到。