Question

我目前正在从事商务扩展方面的工作，在这里我无法使用依赖注入，并且必须将软件包的数量降至最低。

我正在使用PetaPoco作为微型模具。

我创建了一个工作单元来处理dbcontext，并创建了一个工厂来获取我的存储库。

我想以一种直接的方式访问我的存储库中的方法，而不在我的服务中实现任何处理逻辑，因为它们可能用在非一次性的类/对象中。

    public class OrderService : BaseService, IOrderService
    {
        public OrderService() : base(new UnitOfWorkProvider(), new 
        RepositoryFactory())
        {
        }

        public IEnumerable<CommerceOrder> GetAll()
        {
            using (var repo = 
                  RepositoryFactory.
                  CreateOrderRepositiory(UnitOfWorkProvider.GetUnitOfWork()))
            {
                  return repo.GetAll();
            }
         }
    }

所有存储库都实现IDisposable并负责在UOW中调用处置。这已在Baserepo类中实现。

回购工厂

    public class RepositoryFactory 
    {
            internal virtual OrderRepository CreateOrderRepositiory(IUnitOfWork unitOfWork)
            {
                return new OrderRepository(unitOfWork);
            }
    }

样品回购

    public class OrderRepository : RepositoryBase<CommerceOrder>, 
    IOrderRepository<CommerceOrder>
    {
        public OrderRepository(IUnitOfWork unitOfWork)
            : base(unitOfWork)
        {
        }
    }

基本存储库


    public class RepositoryBase<TEntity> : IRepository<TEntity>
    {

        #region IDisposable Support
        private bool disposedValue = false; // To detect redundant calls

        protected virtual void Dispose(bool disposing)
        {
            if (!disposedValue)
            {
                if (disposing)
                {
                    UnitOfWork.Dispose();
                }

            disposedValue = true;
            }
        }

        public void Dispose()
        {
            Dispose(true);
        }
    }

UnitOfWork

 public class UnitOfWorkBase : IUnitOfWork
    {
        public UnitOfWorkBase(string connectionStringName, bool useTransaction)
        {
            Context = new Database(connectionStringName);
            _useDispose = true;
            if (!useTransaction) return;

            _transaction = new Transaction(Context);
        }

        /// <summary>
        /// For use with other Database instances outside of Unit Of Work
        /// </summary>
        /// <param name="context"></param>
        public UnitOfWorkBase(Database context)
        {
            Context = context;
            _useDispose = false;
        }

        public Database Context { get; private set; }
        private readonly bool _useDispose;
        private Transaction _transaction;

        public void Commit()
        {
            if (_transaction == null) return;

            _transaction.Complete();
            _transaction.Dispose();
            _transaction = null;
        }

        public void Dispose()
        {
            var doThrowTransactionException = false;

            if (_transaction != null)
            {
                Context.AbortTransaction();
                _transaction.Dispose();
                doThrowTransactionException = true;
            }

            if (_useDispose && Context != null)
            {
                Context.Dispose();
                Context = null;
            }

            if (doThrowTransactionException)
                throw new DataException("Transaction was aborted");
        }
    }

我应该在工作单元实现中公开存储库，还是可以使用这种方法？我不喜欢将工作单元实现承担这种责任的想法。

在服务层公开的UnitOfWork。我正确地解决了吗？

0 个答案: