tl; dr

Em um bom design. O acesso ao banco de dados deve ser tratado em uma camada lógica de negócios separada (em um modelo asp.net MVC) ou é aceitável passarIQueryables ouDbContext objetos para um controlador?

Por quê? Quais são os prós e contras de cada um?

Eu estou construindo uma aplicação asp.net MVC em c #. UsaEstrutura de entidade como um ORM.

Vamos simplificar um pouco este cenário.

Eu tenho uma tabela de banco de dados com gatinhos fofos fofos. Cada gatinho tem um link de imagem de gatinho, índice de fofura de gatinho, nome de gatinho e id de gatinho. Estes mapeiam para um POCO gerado pelo EF chamadoKitten. Eu poderia usar essa classe em outros projetos e não apenas no projeto asp.net MVC.

eu tenho umKittenController que deve buscar os gatinhos fofos mais recentes em/Kittens. Pode conter alguma lógica selecionando o gatinho, mas não muita lógica. Eu tenho discutido com um amigo sobre como implementar isso, não vou divulgar os lados :)

Opção 1: db no controlador:

public ActionResult Kittens() // some parameters might be here
{
   using(var db = new KittenEntities()){ // db can also be injected,
       var result = db.Kittens // this explicit query is here
                      .Where(kitten=>kitten.fluffiness > 10) 
                      .Select(kitten=>new {
                            Name=kitten.name,
                            Url=kitten.imageUrl
                      }).Take(10); 
       return Json(result,JsonRequestBehavior.AllowGet);
   }
}

Opção 2: modelo separado

public class Kitten{
   public string Name {get; set; }
   public string Url {get; set; }
   private Kitten(){
        _fluffiness = fluffinessIndex;
   }

   public static IEnumerable<Kitten> GetLatestKittens(int fluffinessIndex=10){ 
        using(var db = new KittenEntities()){ //connection can also be injected
            return db.Kittens.Where(kitten=>kitten.fluffiness > 10)
                     .Select(entity=>new Kitten(entity.name,entity.imageUrl))
                     .Take(10).ToList();
        }
    } // it's static for simplicity here, in fact it's probably also an object method
      // Also, in practice it might be a service in a services directory creating the
      // Objects and fetching them from the DB, and just the kitten MVC _type_ here

}

//----Then the controller:
public ActionResult Kittens() // some parameters might be here
{
    return Json(Kittens.GetLatestKittens(10),JsonRequestBehavior.AllowGet);
}

Notas:GetLatestKittens É improvável que seja usado em outro lugar no código, mas pode ser. É possível usar o construtor deKitten em vez de um método de construção estática e alterando a classe para gatinhos. Basicamente é suposto ser uma camadaacima as entidades do banco de dados, de modo que o controlador não precise estar ciente do banco de dados, do mapeador ou da estrutura da entidade.

Quais são alguns prós e contras de cada design?Existe um vencedor claro? Por quê?

Nota: Claro, abordagens alternativas sãomuito valorizado como respostas também.

Esclarecimento 1: Isto énão uma aplicação trivial na prática. Este é um aplicativo com dezenas de controladores e milhares de linhas de código, e as entidades não são usadas apenas aqui, mas em dezenas de outros projetos C #. O exemplo aqui é umcaso de teste reduzido.