标签: unit-of-work

我有UnitofWork类,它实现了IUnitOfWork.我试着用autofac注册:

var builder = new ContainerBuilder();
builder
    .RegisterGeneric(typeof(UnitOfWork<Repository<>,>))
    .As(typeof(IUnitOfWork))
    .InstancePerDependency();

实施是:

public class UnitOfWork<T, O> : IUnitOfWork
    where T : Repository<O>
    where O : BaseEntity
{
}

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

给出"预期类型"错误

但是这个工作在另一个项目上:

public class Repository<T> : GenericRepository<T> 
    where T : BaseEntity
{
    public Repository(IDbContext context)
        : base(context) { }   
}

public abstract class GenericRepository<T> 
    : IRepository<T>, IQueryable<T> where T : BaseEntity
{
}

builder
    .RegisterGeneric(typeof(Repository<>))
    .As(typeof(IRepository<>))
    .InstancePerHttpRequest();

我正在使用ASP.NET Webforms + EF4开始一个新的Web项目.我正在尝试按照本教程应用具有工作单元模式的存储库模式:http://www.dotnetage.com/publishing/home/2011/07/05/6883/the-repository-pattern-with-ef -code先dependeny喷射在-ASP净mvc3.html

我想我有了这个想法,但我的问题是,当我在模型中创建一个新对象时,我是否还必须在工作单元的IDALContext中定义该对象？这不是一个快速发展的手？此外,如果您与多个开发人员合作,并且如果您不希望其他开发人员看到您的DAL,您如何管理它？因为在我理解的模式中,当您在模型中创建新对象时,您还必须在本教程的IDALContext中定义它.对不起,我很困惑.

我看过这个,这让我三思而后行......:

"避免工作单元模式.聚合根应该定义事务边界."

为什么有人应该避免使用域驱动设计的UOW模式？

想知道我是否需要使用Genericrepository模式和UnitOfWork来模拟存储库.我正在使用MOQ.Is它现在是多余的,因为我注意到EF 4.1有IDBSet.

我还没弄明白如何编写一些通用的IDBSet.如果你有一个实例IDBSet的例子,你能告诉我吗？

有什么建议？

在阅读了大量文章之后,我仍然不确定在与存储库交互时工作单元模式的职责.

存储库负责加载和保存聚合根实体,因此请考虑以下示例代码:

using(IUnitOfWork uow = container.CreateUnitOfWork())
{
     Repository<ARoot> roots = container.GetRepository<ARoot>();
     ARoot root = root.FindByName("ARoot");
     root.Name = "ANewName";

     roots.Save(root);
     uow.Commit();
}

工作单元接口将使用以下方法定义:

public interface IUnitOfWork
{
     void Insert(object);
     void Update(object);        
     void Delete(object);
     void Commit();
     void Rollback();
}

可以说存储库是使用非常简单的SQL Mapper实现的,因此FindByName包含一些直接SQL来返回ARoot,Save实现是否如下所示:

public void Save(T entity)
{
      IUnitOfWork uow = GetUnitOfWork();
      // Tell the UOW we are updating this entity
      uow.Update(entity);
}

然后,工作单元提交代码将构造所有必需的SQL以将实体映射回数据库？

问题2)

如果我将聚合根添加到工作单元中,工作单元是否负责持久化根及其子工具,或者应该是存储库的Save方法将已更改的实体添加到工作单元中？例如

public void Save(T entity)
{
      IUnitOfWork uow = GetUnitOfWork();
      // Tell the UOW we are updating this entity …

我编写了一个Symfony命令来从API导入一些数据.它的工作原理但问题是当我在数据库中插入一个大的JSON时,我的PHP内存使用量会增加.并且我的unitOfWork在每次激活导入后增加"2".

我已经取消了所有用过的对象,当你想做大量的批处理时,我已经阅读了Symfony2的文档:http://www.doctrine-project.org/blog/doctrine2-batch-processing.html

但是当我使用$em->clear()我的实体管理器时会出现此错误:

注意:未定义的索引:000000007b56ea7100000000e366c259在path-to-application\vendor\doctrine\lib\Doctrine\ORM\UnitOfWork.php第2228行中

这是我的完整代码:

 /**
 * @see Command
 */
protected function configure() {
  $this
    ->setName('ks:user:runkeepersync')
    ->setDescription('Synchroniser les activités d\'un utilisateur runkeeper')
    ->setDefinition(array(
      new InputArgument('access_token', InputArgument::REQUIRED, 'Access token'),
    ))
}

/**
 * @see Command
 */
protected function execute(InputInterface $input, OutputInterface $output) {
  $accessToken = $input->getArgument('access_token');
  $em = $this->getContainer()->get('doctrine')->getEntityManager();
  $UserHasServices = $em->getRepository('KsUserBundle:UserHasServices')->findOneByToken($accessToken);
  if (!is_object($UserHasServices) ) {
    echo "Impossible de trouver l'utilisateur qui possède le jeton ".$accessToken."";
  }
  $user    = $UserHasServices->getUser();
  $service = $UserHasServices->getService();
  echo "avant de …

这是我第一次实施更加以域驱动的设计方法.我决定尝试使用Onion Architecture,因为它专注于域而不是基础架构/平台/等.

为了从实体框架中抽象出来,我创建了一个带有工作单元实现的通用存储库.

该IRepository<T>和IUnitOfWork接口:

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

    void Remove(T item);

    IQueryable<T> Query();
}

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

实体框架的实现IRepository<T>和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 = …

我想记录一些SQLAlchemy-Models将要完成的操作.

所以,我有一个after_insert,after_delete和before_update钩子,在那里我将保存模型的先前和当前表示,

def keep_logs(cls):
    @event.listens_for(cls, 'after_delete')
    def after_delete_trigger(mapper, connection, target):
        pass

    @event.listens_for(cls, 'after_insert')
    def after_insert_trigger(mapper, connection, target):
        pass

    @event.listens_for(cls, 'before_update')
    def before_update_trigger(mapper, connection, target):
        prev = cls.query.filter_by(id=target.id).one()
        # comparing previous and current model


MODELS_TO_LOGGING = (
    User,
)
for cls in MODELS_TO_LOGGING:
    keep_logs(cls)

但是有一个问题:当我试图在before_update钩子中找到模型时,SQLA返回修改(脏)版本.如何在更新之前获取以前版本的模型？是否有不同的方法来保持模型更改？

谢谢!

我试图通过将一个工作单元实例传递到我的存储库来实现一个工作单元模式.

来自Global.asax的相关代码.

public class SiteModule : NinjectModule
{
    public override void Load() {        
       Bind<IUnitOfWork>().To<SqlUnitOfWork>()
                          .InRequestScope()
                          .WithConstructorArgument("connectionString", ConfigurationManager.ConnectionStrings["Entities"].ConnectionString);

       Bind<IProductRepository>().To<ProductRepository>();
       Bind<ICategoryRepository>().To<CategoryRepository>();
    }
}

存储库构造函数:

public class ProductRepository {
    IUnitOfWork unitOfWork;
    public ProductRepository(IUnitOfWork unitOfWork) {
        this.unitOfWork = unitOfWork;
    }
}

public class CategoryRepository {
    IUnitOfWork unitOfWork;
    public CategoryRepository(IUnitOfWork unitOfWork) {
        this.unitOfWork = unitOfWork;
    }
}

我想要的是SqlUnitOfWork每个请求最多创建一个实例并传递到我的存储库(通过它们各自的构造函数).

绑定InRequestScope()方法是否IUnitOfWork足够？如果不是我怎么能实现这一目标？

我正在构建一个ORM,并试图找出每个模式的确切职责.假设我想在两个帐户之间转移资金,使用工作单元来管理单个数据库事务中的更新.以下方法是否正确？

1. 从存储库中获取它们
2. 将它们附加到我的工作单元
3. 做生意交易和提交？

例:

from = acccountRepository.find(fromAccountId);
to = accountRepository.find(toAccountId);

unitOfWork.attach(from);
unitOfWork.attach(to);    

unitOfWork.begin();
from.withdraw(amount);
to.deposit(amount);
unitOfWork.commit();

应该像在这个例子中那样独立使用工作单元和存储库,或者:

• 工作单元是否应该在内部使用存储库并且能够加载对象？
• ...或者存储库是否应在内部使用工作单元并自动附加任何已加载的实体？

欢迎所有评论!