asp.net-mvc - 在 Controller 中进行 linq 查询是一种好习惯吗？

Question

我对 MVC 模式不是很熟悉。您能告诉我以下三个 Controller 操作中的哪一个更好吗？谢谢 :)

(1) 有查询在行动:

public ActionResult List()
{
   var query = repository.Query().Where(it => it.IsHandled).OrderBy(it => it.Id);
   // ...
}

(2) 服务中查询:

public ActionResult List() 
{
    var items = service.GetHandledItemsOrderById();
    // ...
}

(3) 有订单在行动:

public ActionResult List()
{
    var items = service.GetHandledItems().OrderBy(it => it.Id);
    // ...
}

如果我们选择(1)，那么我们 Controller 中的业务逻辑太多了？

如果我们选择(2)，可能会有很多服务方法，比如 GetXXXByYYY() .

如果选择(3)，为什么要封装 Where(it => it.IsHandled)但不是 OrderBy(it => it.Id .

有任何想法吗？

Answer 1

这取决于。 :)

我的意见:

我喜欢让我的服务保持宽松，以尽量减少重复的代码。我也是管道和过滤器的粉丝。

这就是我要做的(并且要做)。

服务

public ICollection<Item> GetHandledItems<TKey>(OrderingOptions<Item, TKey> orderingOptions) 
{
   return repository
      .Query()
      .WhereHandled()
      .WithOrdering(orderingOptions)
      .ToList();     
}

ItemFilters.cs

public static IQueryable<Item> WhereHandled(this IQueryable<Item> source)
{
   return source.Where(it => it.IsHandled);
}

public static IOrderedQueryable<T> WithOrdering<T, TKey>(
   this IQueryable<T> source,
   OrderingOptions<T, TKey> orderingOptions)
{
   return orderingOptions.SortDescending 
      ? source.OrderByDescending(orderingOptions.OrderingKey) :                                                    
        source.OrderBy(orderingOptions.OrderingKey);
}

OrderingOptions.cs

 public class OrderingOptions<T,TKey>
 {
    public OrderingOptions(Expression<Func<T,TKey>> orderingKey, bool sortDescending = false)
    {
       OrderingKey = orderingKey;
       SortDescending = sortDescending;
    }

    public Expression<Func<T,TKey>> OrderingKey { get; private set; }
    public bool SortDescending { get; private set; }
 }

这样，您可以在 Controller 中指定排序:

var items = service.GetHandledItems(new OrderingOptions(it => it.Id));

以上与选项3的区别:

以上在返回 Controller 之前实现序列。选项 3 没有，这很危险(您最终可能会将查询返回到 View 并破坏 MVC 模式)。

通用“订购”POCO，可以在任何地方使用，并保持您的查询 D-R-Y。

服务变成哑 ，并且只是存储库和 Controller 之间的缓解器(这是它应该做的，IMO)。抽象到一处的逻辑(例如过滤器)。