这是我第一次实现更加领域驱动的设计方法。我决定试试 Onion Architecture因为它专注于领域而不是基础设施/平台/等。

为了从 Entity Framework 中抽象出来，我创建了一个带有工作单元实现的通用存储库。

IRepository<T>和 IUnitOfWork接口(interface):

public interface IRepository<T>
{
    void Add(T item);

    void Remove(T item);

    IQueryable<T> Query();
}

public interface IUnitOfWork : IDisposable
{
    void SaveChanges();
}

IRepository<T> 的 Entity Framework 实现和 IUnitOfWork :

public class EntityFrameworkRepository<T> : IRepository<T> where T : class
{
    private readonly DbSet<T> dbSet;

    public EntityFrameworkRepository(IUnitOfWork unitOfWork)
    {
        var entityFrameworkUnitOfWork = unitOfWork as EntityFrameworkUnitOfWork;

        if (entityFrameworkUnitOfWork == null)
        {
            throw new ArgumentOutOfRangeException("Must be of type EntityFrameworkUnitOfWork");
        }

        dbSet = entityFrameworkUnitOfWork.GetDbSet<T>();
    }

    public void Add(T item)
    {
        dbSet.Add(item);
    }

    public void Remove(T item)
    {
        dbSet.Remove(item);
    }

    public IQueryable<T> Query()
    {
        return dbSet;
    }
}

public class EntityFrameworkUnitOfWork : IUnitOfWork
{
    private readonly DbContext context;

    public EntityFrameworkUnitOfWork()
    {
        this.context = new CustomerContext();;
    }

    internal DbSet<T> GetDbSet<T>()
        where T : class
    {
        return context.Set<T>();
    }

    public void SaveChanges()
    {
        context.SaveChanges();
    }

    public void Dispose()
    {
        context.Dispose();
    }
}

客户存储库:

public interface ICustomerRepository : IRepository<Customer>
{

}

public class CustomerRepository : EntityFrameworkRepository<Customer>, ICustomerRepository 
{
    public CustomerRepository(IUnitOfWork unitOfWork): base(unitOfWork)
    {
    }
}

使用存储库的 ASP.NET MVC Controller :

public class CustomerController : Controller
{
    UnityContainer container = new UnityContainer();

    public ActionResult List()
    {
        var unitOfWork = container.Resolve<IUnitOfWork>();
        var customerRepository = container.Resolve<ICustomerRepository>();

        return View(customerRepository.Query());
    }

    [HttpPost]
    public ActionResult Create(Customer customer)
    {
        var unitOfWork = container.Resolve<IUnitOfWork>();
        var customerRepository = container.Resolve<ICustomerRepository>();; 

        customerRepository.Add(customer);

        unitOfWork.SaveChanges();

        return RedirectToAction("List");
    }
}

统一的依赖注入(inject):

container.RegisterType<IUnitOfWork, EntityFrameworkUnitOfWork>();
container.RegisterType<ICustomerRepository, CustomerRepository>();

解决方法:

有问题吗？

• 存储库实现(EF 代码)非常通用。这一切都在 EntityFrameworkRepository<T> 旁边类(class)。具体模型存储库不包含任何此逻辑。这使我免于编写大量冗余代码，但可能会牺牲灵 active ？

• ICustomerRepository和 CustomerRepository类基本上是空的。它们纯粹是为了提供抽象。据我了解，这符合洋葱架构的愿景，即基础设施和平台相关代码位于系统外部，但空类和空接口(interface)感觉不对？

• 要使用不同的持久性实现(比如 Azure 表存储)，然后是一个新的 CustomerRepository需要创建类并将继承 AzureTableStorageRepository<T> .但这会导致冗余代码(多个 CustomerRepositories)吗？这将如何影响模拟？

• 另一个实现(例如 Azure 表存储)对跨国支持有限制，因此 AzureTableStorageUnitOfWork 类在这种情况下不起作用。

我这样做的方式还有其他问题吗？

(我的大部分灵感来自 this post )

最佳答案

我可以说这段代码对于第一次尝试来说已经足够好了，但它确实有一些需要改进的地方。

让我们来看看其中的一些。

<强>1。依赖注入(inject) (DI) 和 IoC 的使用。

您使用最简单的版本 Service Locator pattern - container实例本身。

我建议您使用“构造函数注入(inject)”。您可以找到更多信息here (ASP.NET MVC 4 Dependency Injection) .

public class CustomerController : Controller
{
    private readonly IUnitOfWork unitOfWork;
    private readonly ICustomerRepository customerRepository;

    public CustomerController(
        IUnitOfWork unitOfWork, 
        ICustomerRepository customerRepository)
    {
        this.unitOfWork = unitOfWork;
        this.customerRepository = customerRepository;
    }

    public ActionResult List()
    {
        return View(customerRepository.Query());
    }

    [HttpPost]
    public ActionResult Create(Customer customer)
    {
        customerRepository.Add(customer);
        unitOfWork.SaveChanges();
        return RedirectToAction("List");
    }
}

<强>2。工作单元 (UoW) 范围。

我找不到IUnitOfWork 的生活方式|和 ICustomerRepository .我不熟悉 Unity 但 msdn says that TransientLifetimeManager is used by default .这意味着每次解析类型时都会得到一个新实例。

所以，下面的测试失败了:

[Test]
public void MyTest()
{
    var target = new UnityContainer();
    target.RegisterType<IUnitOfWork, EntityFrameworkUnitOfWork>();
    target.RegisterType<ICustomerRepository, CustomerRepository>();

    //act
    var unitOfWork1 = target.Resolve<IUnitOfWork>();
    var unitOfWork2 = target.Resolve<IUnitOfWork>();

    // assert
    // This Assert fails!
    unitOfWork1.Should().Be(unitOfWork2);
} 

我希望 UnitOfWork 的那个实例在您的 Controller 中不同于 UnitOfWork 的实例在您的存储库中。有时可能会导致错误。但在 ASP.NET MVC 4 Dependency Injection 中并未突出显示作为 Unity 的一个问题。

在Castle Windsor PerWebRequest lifestyle 用于在单个 http 请求中共享相同的类型实例。

当 UnitOfWork 时，这是常见的方法是 PerWebRequest零件。定制ActionFilter可用于调用 Commit()在调用 OnActionExecuted() 期间方法。

我还会重命名 SaveChanges()方法并简单地调用它 Commit因为它在 example 中被称为在PoEAA .

public interface IUnitOfWork : IDisposable
{
    void Commit();
}

3.1。对存储库的依赖。

如果您的存储库将是“空的”，则不需要为它们创建特定的接口(interface)。可以解决 IRepository<Customer>并在您的 Controller 中包含以下代码

public CustomerController(
    IUnitOfWork unitOfWork, 
    IRepository<Customer> customerRepository)
{
    this.unitOfWork = unitOfWork;
    this.customerRepository = customerRepository;
}

有一个测试可以测试它。

[Test]
public void MyTest()
{
    var target = new UnityContainer();
    target.RegisterType<IRepository<Customer>, CustomerRepository>();

    //act
    var repository = target.Resolve<IRepository<Customer>>();

    // assert
    repository.Should().NotBeNull();
    repository.Should().BeOfType<CustomerRepository>();
}

但是如果您希望存储库是“集中查询构造代码的映射层之上的抽象层”。 ( PoEAA, Repository )

A Repository mediates between the domain and data mapping layers, acting like an in-memory domain object collection. Client objects construct query specifications declaratively and submit them to Repository for satisfaction.

3.2。继承 EntityFrameworkRepository。

在这种情况下，我会创建一个简单的 IRepository

public interface IRepository
{
    void Add(object item);

    void Remove(object item);

    IQueryable<T> Query<T>() where T : class;
}

及其实现知道如何与 EntityFramework 基础设施一起工作，并且可以很容易地被另一个基础设施取代(例如 AzureTableStorageRepository)。

public class EntityFrameworkRepository : IRepository
{
    public readonly EntityFrameworkUnitOfWork unitOfWork;

    public EntityFrameworkRepository(IUnitOfWork unitOfWork)
    {
        var entityFrameworkUnitOfWork = unitOfWork as EntityFrameworkUnitOfWork;

        if (entityFrameworkUnitOfWork == null)
        {
            throw new ArgumentOutOfRangeException("Must be of type EntityFrameworkUnitOfWork");
        }

        this.unitOfWork = entityFrameworkUnitOfWork;
    }

    public void Add(object item)
    {
        unitOfWork.GetDbSet(item.GetType()).Add(item);
    }

    public void Remove(object item)
    {
        unitOfWork.GetDbSet(item.GetType()).Remove(item);
    }

    public IQueryable<T> Query<T>() where T : class
    {
        return unitOfWork.GetDbSet<T>();
    }
}

public interface IUnitOfWork : IDisposable
{
    void Commit();
}

public class EntityFrameworkUnitOfWork : IUnitOfWork
{
    private readonly DbContext context;

    public EntityFrameworkUnitOfWork()
    {
        this.context = new CustomerContext();
    }

    internal DbSet<T> GetDbSet<T>()
        where T : class
    {
        return context.Set<T>();
    }

    internal DbSet GetDbSet(Type type)
    {
        return context.Set(type);
    }

    public void Commit()
    {
        context.SaveChanges();
    }

    public void Dispose()
    {
        context.Dispose();
    }
}

现在CustomerRepository可以代理并引用它。

public interface IRepository<T> where T : class
{
    void Add(T item);

    void Remove(T item);
}

public abstract class RepositoryBase<T> : IRepository<T> where T : class
{
    protected readonly IRepository Repository;

    protected RepositoryBase(IRepository repository)
    {
        Repository = repository;
    }

    public void Add(T item)
    {
        Repository.Add(item);
    }

    public void Remove(T item)
    {
        Repository.Remove(item);
    }
}

public interface ICustomerRepository : IRepository<Customer>
{
    IList<Customer> All();

    IList<Customer> FindByCriteria(Func<Customer, bool> criteria);
}

public class CustomerRepository : RepositoryBase<Customer>, ICustomerRepository
{
    public CustomerRepository(IRepository repository)
        : base(repository)
    { }

    public IList<Customer> All()
    {
        return Repository.Query<Customer>().ToList();
    }

    public IList<Customer> FindByCriteria(Func<Customer, bool> criteria)
    {
        return Repository.Query<Customer>().Where(criteria).ToList();
    }
}

关于c# - 洋葱架构、工作单元和通用存储库模式，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/20473327/