Asp.net mvc 使用工作单元和存储库

我试图在我的项目中使用工作单元和存储库。 这让我想到了如何用它实现事务

目前，我正计划这样做：

public class UnitOfWork : IUnitOfWork
{

    private readonly IDbFactory databaseFactory;
    private adminBoContext dataContext;
    private DbContextTransaction _transaction;

    private Repository<a> repoA;
    ....
    private Repository<x> repoX;

    public UnitOfWork(IDbFactory databaseFactory)
    {
        this.databaseFactory = databaseFactory;
        _transaction = dataContext.Database.BeginTransaction();
    }

    protected Context DataContext
    {
        get { return dataContext ?? (dataContext = databaseFactory.Get()); }
    }

    public void Commit()
    {
        try
        {
            _transaction.Commit();
        }
        catch (Exception ex)
        {
            _transaction.Rollback();
        }
    }
}

公共类UnitOfWork:IUnitOfWork
{
私有只读IDbFactory数据库工厂；
私有adminBoContext数据上下文；
私有DbContextTransaction\u事务；
它拥有的私有存储库
工作单元（但内部没有存储库）和单独的存储库，这些存储库看起来有自己的上下文实例

public class UnitOfWork : IUnitOfWork
{
    private readonly IDatabaseFactory databaseFactory;
    private SocialGoalEntities dataContext;

    public UnitOfWork(IDatabaseFactory databaseFactory)
    {
        this.databaseFactory = databaseFactory;
    }

    protected SocialGoalEntities DataContext
    {
        get { return dataContext ?? (dataContext = databaseFactory.Get()); }
    }

    public void Commit()
    {
        DataContext.Commit();
    }
}

public abstract class RepositoryBase<T> where T : class
{
    private SocialGoalEntities dataContext;
    private readonly IDbSet<T> dbset;
    protected RepositoryBase(IDatabaseFactory databaseFactory)
    {
        DatabaseFactory = databaseFactory;
        dbset = DataContext.Set<T>();
    }

    protected IDatabaseFactory DatabaseFactory
    {
        get;
        private set;
    }

    protected SocialGoalEntities DataContext
    {
        get { return dataContext ?? (dataContext = DatabaseFactory.Get()); }
    }
    public virtual void Add(T entity)
    {
        dbset.Add(entity);
    }

公共类UnitOfWork:IUnitOfWork
{
私有只读IDatabaseFactory databaseFactory；
私人社会背景；
公共工作单元（IDatabaseFactory databaseFactory）
{
this.databaseFactory=数据库工厂；
}
受保护的SocialValenties数据上下文
{
获取{return dataContext？？？（dataContext=databaseFactory.get（））；}
}
公共无效提交（）
{
Commit（）；
}
}
公共抽象类RepositoryBase，其中T:class
{
私人社会背景；
专用只读IDbSet数据库集；
受保护的RepositoryBase（IDatabaseFactory databaseFactory）
{
DatabaseFactory=DatabaseFactory；
dbset=DataContext.Set（）；
}
受保护的IDatabaseFactory数据库工厂
{
得到；
私人设置；
}
受保护的SocialValenties数据上下文
{
获取{return dataContext？？？（dataContext=DatabaseFactory.get（））；}
}
公共虚拟空添加（T实体）
{
添加（实体）；
}

我现在对工作单元和存储库应该如何实现感到困惑，因为据我所知，工作单元将是所有访问存储库的通道

如果有人能介绍一下这个工作单元和存储库实现，我将不胜感激

非常感谢。
数据上下文应该只在工作单元类中创建，并将相同的数据上下文传递到存储库中，该数据上下文也应该在工作单元中提交或回滚

您的存储库不应该创建自己的dataContext，而应该使用从工作单元传入的dataContext。这样，我们就可以跨存储库协调事务

您问题中的示例代码可以如下实现：

public class UnitOfWork : IUnitOfWork
{

    private readonly IDbFactory databaseFactory;
    private adminBoContext dataContext;
    private DbContextTransaction _transaction;

    private Repository<a> repoA;
    private Repository<x> repoX;

    public UnitOfWork(IDbFactory databaseFactory)
    {
        this.databaseFactory = databaseFactory;
        _transaction = DataContext.Database.BeginTransaction();

        //pass the same context to your repositories
        repoA = new Repository<A>(DataContext); 
        repoX = new Repository<X>(DataContext); 
    }

    protected Context DataContext
    {
        get { return dataContext ?? (dataContext = databaseFactory.Get()); }
    }

    public void Commit()
    {
        try
        {
            _transaction.Commit();
        }
        catch (Exception ex)
        {
            _transaction.Rollback();
        }
    }
}

   private bool disposed = false;

   protected virtual void Dispose(bool disposing)
   {
        if (!this.disposed)
        {
            if (disposing)
            {
                dataContext.Dispose();
            }
        }
        this.disposed = true;
   }

   public void Dispose()
   {
        Dispose(true);
        GC.SuppressFinalize(this);
   }

您的代码应类似于：

public class UnitOfWork : IUnitOfWork, IDisposable
    {

        private readonly IDbFactory databaseFactory;
        private adminBoContext dataContext;
        private DbContextTransaction _transaction;

        private Repository<a> repoA;
        private Repository<x> repoX;

        public UnitOfWork(IDbFactory databaseFactory)
        {
            this.databaseFactory = databaseFactory;
            _transaction = DataContext.Database.BeginTransaction();

            //pass the same context to your repositories
            repoA = new Repository<A>(DataContext); 
            repoX = new Repository<X>(DataContext); 
        }

        protected Context DataContext
        {
            get { return dataContext ?? (dataContext = databaseFactory.Get()); }
        }

        public void Commit()
        {
            try
            {
                _transaction.Commit();
            }
            catch (Exception ex)
            {
                _transaction.Rollback();
            }
        }

        private bool disposed = false;

        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    dataContext.Dispose();
                }
            }
            this.disposed = true;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
    }

公共类UnitOfWork:IUnitOfWork，IDisposable
{
私有只读IDbFactory数据库工厂；
私有adminBoContext数据上下文；
私有DbContextTransaction\u事务；
私有存储库repoA；
私有存储库repoX；
公共工作单元（IDbFactory databaseFactory）
{
this.databaseFactory=数据库工厂；
_事务=DataContext.Database.BeginTransaction（）；
//将相同的上下文传递到存储库
repoA=新存储库（DataContext）；
repoX=新存储库（DataContext）；
}
受保护上下文数据上下文
{
获取{return dataContext？？？（dataContext=databaseFactory.get（））；}
}
公共无效提交（）
{
尝试
{
_Commit（）；
}
捕获（例外情况除外）
{
_transaction.Rollback（）；
}
}
私有布尔=假；
受保护的虚拟void Dispose（bool disposing）
{
如果（！this.disposed）
{
如果（处置）
{
Dispose（）；
}
}
这是真的；
}
公共空间处置（）
{
处置（真实）；
总干事（本）；
}
}

您的存储库：

public abstract class RepositoryBase<T> : IRepository<T>
    where T : class 
{
    protected DbSet<T> Set { get; set; }
    protected Context Context { get; private set; }

    protected RepositoryBase(Context dataContext)
    {
        Context = dataContext;
        Set = Context.Set<T>();          
    }

公共抽象类RepositoryBase:IRepository
T:在哪里上课
{
受保护的DbSet集{get；Set；}
受保护的上下文{get；private set；}
受保护的RepositoryBase（上下文dataContext）
{
上下文=数据上下文；
Set=Context.Set（）；
}
应仅在工作单元类中创建数据上下文，并将相同的数据上下文传递到存储库中，该数据上下文也应在工作单元中提交或回滚

您的存储库不应该创建自己的dataContext，而应该使用从工作单元传入的dataContext。这样，我们就可以跨存储库协调事务

您问题中的示例代码可以如下实现：

public class UnitOfWork : IUnitOfWork
{

    private readonly IDbFactory databaseFactory;
    private adminBoContext dataContext;
    private DbContextTransaction _transaction;

    private Repository<a> repoA;
    private Repository<x> repoX;

    public UnitOfWork(IDbFactory databaseFactory)
    {
        this.databaseFactory = databaseFactory;
        _transaction = DataContext.Database.BeginTransaction();

        //pass the same context to your repositories
        repoA = new Repository<A>(DataContext); 
        repoX = new Repository<X>(DataContext); 
    }

    protected Context DataContext
    {
        get { return dataContext ?? (dataContext = databaseFactory.Get()); }
    }

    public void Commit()
    {
        try
        {
            _transaction.Commit();
        }
        catch (Exception ex)
        {
            _transaction.Rollback();
        }
    }
}

   private bool disposed = false;

   protected virtual void Dispose(bool disposing)
   {
        if (!this.disposed)
        {
            if (disposing)
            {
                dataContext.Dispose();
            }
        }
        this.disposed = true;
   }

   public void Dispose()
   {
        Dispose(true);
        GC.SuppressFinalize(this);
   }

您的代码应类似于：

public class UnitOfWork : IUnitOfWork, IDisposable
    {

        private readonly IDbFactory databaseFactory;
        private adminBoContext dataContext;
        private DbContextTransaction _transaction;

        private Repository<a> repoA;
        private Repository<x> repoX;

        public UnitOfWork(IDbFactory databaseFactory)
        {
            this.databaseFactory = databaseFactory;
            _transaction = DataContext.Database.BeginTransaction();

            //pass the same context to your repositories
            repoA = new Repository<A>(DataContext); 
            repoX = new Repository<X>(DataContext); 
        }

        protected Context DataContext
        {
            get { return dataContext ?? (dataContext = databaseFactory.Get()); }
        }

        public void Commit()
        {
            try
            {
                _transaction.Commit();
            }
            catch (Exception ex)
            {
                _transaction.Rollback();
            }
        }

        private bool disposed = false;

        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed)
            {
                if (disposing)
                {
                    dataContext.Dispose();
                }
            }
            this.disposed = true;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
    }

公共类UnitOfWork:IUnitOfWork，IDisposable
{
私有只读IDbFactory数据库工厂；
私有adminBoContext数据上下文；
私有DbContextTransaction\u事务；
私有存储库repoA；
私有存储库repoX；
公共工作单元（IDbFactory databaseFactory）
{
this.databaseFactory=数据库工厂；
_事务=DataContext.Database.BeginTransaction（）；
//将相同的上下文传递到存储库
repoA=新存储库（DataContext）；
repoX=新存储库（DataContext）；
}
受保护上下文数据上下文
{
获取{return dataContext？？？（dataContext=databaseFactory.get（））；}
}
公共无效提交（）
{
尝试
{
_Commit（）；
}
捕获（例外情况除外）
{
_transaction.Rollback（）；
}
}
私有布尔=假；
受保护的虚拟void Dispose（bool disposing）
{
如果（！this.disposed）