C# ReadOnlyUnitOfWork（IDBManager、dbManager、IRepositoryProvider、repoProvider）：基本（dbManager、repoProvider） { _dbManager=dbManager； _repositoryProvider=repositoryProvider； } } 公共类ReadWriteUnitOfWork:BaseUnitOfWork//此处是您的接口 { 私人交易范围(u)交易;； public ReadWriteUnitOfWork（IDBManager dbManager，IRepositoryProvider repoProvider）：base（dbManager，repoProvider） { 如果（_事务==null） _transaction=新TransactionScope（）； } 公共作废保存（） { _transaction.Complete（）； } 公共空间处置（） { _transaction.Dispose（）； } }

我已经在几个项目中成功地使用了这个策略

这个策略的好处在于，您遵守了SOLID（）设计中的S：单一责任

一个类负责处理带有事务的数据库操作，而另一个类只处理无事务的操作

此外，您必须理解工作块的单元应该是快速的（在执行中）和（如果可能的话）代码小的（作为最佳实践）

因此，您可以这样使用它：

public class UnitOfWork : IUnitOfWork, IDisposable
{
    /// <summary>
    /// DB context.
    /// </summary>
    private IDBManager _dbManager;

    /// <summary>
    /// Repository provider class which can create repositories on demand.
    /// </summary>
    private IRepositoryProvider _repositoryProvider;

    private TransactionScope _transaction;

    public UnitOfWork(IDBManager dbManager, IRepositoryProvider repoProvider)
    {
        _dbManager = dbManager;
        _repositoryProvider = repoProvider;
    }

    public T GetRepository<T>()
    {
        if (_transaction == null)
            _transaction = new TransactionScope();

        return _repositoryProvider.Create<T>(_dbManager);
    }

    public void Save()
    {
        _transaction.Complete();
    }

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

using( IReadWriteUnitOfWork uow = InjectionFramework.ResolveDependencyOfType<IReadWriteUnitOfWork>() )
{
    //do your database stuff here, try to keep it simple.
    //after doing everything, you **commit** the transaction (in your case, you save)
    uow.Save();
}

使用（IReadWriteUnitOfWork uow=InjectionFramework.ResolveDependencyOfType（））
{
//在这里做你的数据库工作，尽量保持简单。
//完成所有操作后，您**提交**事务（在您的情况下，您保存）
uow.Save（）；
}

---

使用命令的好处在于，在完成这段代码后，它会自动调用dispose方法。

哇，太棒了。非常感谢你的想法。其想法是以某种方式强制所有更新/删除操作在同一事务伞下工作，我认为您的方法允许这样做。我还想问一下，在UoW中创建一个TransactionScope是否合适，然后在我与DB合作并执行其他活动时，让它一直存在、打开。还是我在这里遗漏了什么？当打开TransactionScope时，可能有些操作的工作方式不同，而不仅仅是DB请求？我正在尝试使用您建议的方法。正如我提到的，我使用Ninject。它将UoW注入我的控制器，然后我使用它创建存储库。现在，我需要注入某种类型的UoW工厂，通过它创建所需的UoW类型对象，而不是UoW。我猜，关于您的第一个评论，您必须理解工作块的单元应该尽可能快（和小）。否则，您将开始出现数据库性能问题。因此，在使用uow时，您应该尽量使其非常小。为了举例说明，我将编辑答案。然后，对于您的第二条评论，您可以像我显示的那样使用它：InjectionContainer.Resolve。。。。您可以在注入容器配置块中定义，将IReadWrite解析为ReadWrite，将IReadOnly解析为ReadOnly。（您只需要从ReadWrite&ReadOnly实现类中提取接口。但不要忘记也为基类使用接口），而且，如果这解决了您的问题，也不要忘记“接受”它作为答案。：）我跑步是为了在堆栈溢出附近获得一些声誉。：）

    public TicketPost AddTicketPost(int tid, TicketPost update)
    {
        TicketPost post = Uow.GetRepository<ITicketsRepository>().AddPost(tid, update);
        Uow.Save();

        return post;
    }

Uow.BeginTransaction();
try
{
    TicketPost post = Uow.GetRepository<ITicketsRepository>().AddPost(tid, update);
}
catch (Exception e)
{
    Uow.RollbacTransaction();
}
Uow.CommitTransaction();

public class BaseUnitOfWork // YOUR INTERFACES HERE
{
    /// <summary>
    /// DB context.
    /// </summary>
    private IDBManager _dbManager;

    /// <summary>
    /// Repository provider class which can create repositories on demand.
    /// </summary>
    private IRepositoryProvider _repositoryProvider;

    public BaseUnitOfWork(IDBManager dbManager, IRepositoryProvider repoProvider)
    {
        _dbManager = dbManager;
        _repositoryProvider = repoProvider;
    }

    public T GetRepository<T>()
    {
        return _repositoryProvider.Create<T>(_dbManager);
    }
}

public class ReadOnlyUnitOfWork : BaseUnitOfWork
{
    public ReadOnlyUnitOfWork(IDBManager dbManager, IRepositoryProvider repoProvider) : base(dbManager,repoProvider)
    {
        _dbManager = dbManager;
        _repositoryProvider = repoProvider;
    }
}

public class ReadWriteUnitOfWork : BaseUnitOfWork// YOUR INTERFACES HERE
{
    private TransactionScope _transaction;

    public ReadWriteUnitOfWork(IDBManager dbManager, IRepositoryProvider repoProvider) : base(dbManager,repoProvider)
    {
        if (_transaction == null)
            _transaction = new TransactionScope();
    }

    public void Save()
    {
        _transaction.Complete();
    }

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

using( IReadWriteUnitOfWork uow = InjectionFramework.ResolveDependencyOfType<IReadWriteUnitOfWork>() )
{
    //do your database stuff here, try to keep it simple.
    //after doing everything, you **commit** the transaction (in your case, you save)
    uow.Save();
}