Po prostu chciałem uzyskać informacje zwrotne / pomoc w sposobie projektowania mojej aplikacji. Moja obecna struktura rozwiązania wygląda mniej więcej tak:

Interfejs użytkownika (aktualna aplikacja MVC)Core (tylko kontrolery i ViewModels)UsługiBLLDane (struktura DbContext Entity, odwzorowana na obiekty domeny)Domena (proste obiekty POCO)Interfejsy

Inne rzeczy

Ninject, aby wstrzyknąć DbContext do kontrolera (na żądanie)AutoMapper do mapowania obiektów domeny na ViewModel

Wszystkie zespoły mają odniesienie do projektu Interfaces, który, jak sugeruje nazwa, jest niczym innym jak prostymi interfejsami (tj. IDbContext, IRepository itp.).

Projekt Usługi „łączy” wszystko inne. Jest to jedyny zespół, który ma bezpośrednie odniesienie do warstwy dostępu do danych (Entity Framework).

Podałem kod poniżej:

Przykład kontrolera wygląda tak:

namespace Core.Controllers
{
    public class HomeController : Controller
    {
        private IDbContext dbContext;

        public HomeController(IDbContext dbContext)
        {
            this.dbContext = dbContext;
        }

        public ActionResult Users()
        {
            UserService userService = new UserService(dbContext);
            var users = userService.GetAllUsers();
            return View(Mapper.Map<IEnumerable<UserListViewModel>>(users));
        }
        ...

Klasa UserService:

namespace Services
{
    public class UserService
    {
        private readonly IDbContext dbContext;

        public UserService(IDbContext dbContext)
        {
            this.dbContext = dbContext;
        }

        public IEnumerable<User> GetAllUsers()
        {
            IRepository<User> userRepository = new Repository<User>(dbContext);
            UserBLL userBLL = new UserBLL(userRepository);
            return userBLL.GetAllUsers();
        }
        ...

Wreszcie klasa warstwy biznesowej:

namespace BLL
{
    public class UserBLL
    {
        private readonly IRepository<User> userRepository;

        public UserBLL(IRepository<User> userRepository)
        {
            this.userRepository = userRepository;
        }

        public IEnumerable<User> GetAllUsers()
        {
            return userRepository.Get();
        }
        ...

Szukam opinii / sposobów na poprawę. Zauważam, że dla podstawowych zadań moje metody warstwy usług będą dokładnie takie same jak metody warstwy biznesowej (tj. Funkcje „przechodzą”). Mam nadzieję, że ta abstrakcja będzie pomocna w bardziej złożonych zadaniach, które mogą wymagać wywołań wielu metod warstwy biznesowej. Czy po prostu lepiej byłoby włączyć logikę biznesową do warstwy usług?