BeginTran(), Commit() et Rollback() dans le modèle de référentiel

Question

Lors de la création d'un référentiel en utilisant NHibetnate (ou, peu importe), devrais-je garder BeginTransaction(), Commit(), Rollback() comme ceci?

public class NHibernateRepository<T> : IRepository<T> 
{ 
    private NHibernate.ISession _session; 

    public NHibernateRepository() 
    { 
     _session = NHibernateSessionManager.Instance.GetSession(); 
     _session.BeginTransaction(); 
    } 

    public void Save(T obj) 
    { 
     _session.Save(obj); 
    } 

    ... ... ... ... ... ... ... 

    public void Commit() 
    { 
     if (_session.Transaction.IsActive) 
     { 
      _session.Transaction.Commit(); 
     } 
    } 

    public void Rollback() 
    { 
     if (_session.Transaction.IsActive) 
     { 
      _session.Transaction.Rollback(); 
      _session.Clear(); 
     } 
    } 

    public void BeginTransaction() 
    { 
     Rollback(); 
     _session.BeginTransaction(); 
    } 
} 

Ou, devrais-je écrire mes méthodes de persistance comme ceci?

public class Repository<T> : IRepository<T> 
    { 
     ISession _session; 

     public Repository() 
     { 
      _session = SessionFactoryManager.SessionFactory.OpenSession(); 
     } 

     private void Commit() 
     { 
      if (_session.Transaction.IsActive) 
      { 
       _session.Transaction.Commit(); 
      } 
     } 

     private void Rollback() 
     { 
      if (_session.Transaction.IsActive) 
      { 
       _session.Transaction.Rollback(); 
       _session.Clear(); 
      } 
     } 

     private void BeginTransaction() 
     { 
      _session.BeginTransaction(); 
     } 

     void IRepository<T>.Save(T obj) 
     { 
      try 
      { 
       this.BeginTransaction(); 

       _session.Save(obj);     

       this.Commit(); 
      } 
      catch (Exception ex) 
      { 
       this.Rollback(); 

       throw ex; 
      }    
     } 

     ... ... ... ... ... ... ... 
    } 
} 

Une suggestion? Quelqu'un peut-il comparer ces deux approches?

Answer 1

Créez un ITransactionManager distinct, qui renverra My.ITransaction que vous validerez et annulerez ultérieurement si nécessaire.

Actuellement vous êtes juste pollutin interface de classe et en introduisant la complexité et bizarreries (par exemple, puis-je appeler BeginTransation dans un référentiel, puis Commit dans une autre?).

Answer 2

Mon approche est de laisser l'interface utilisateur/quoi que ce soit contrôler la portée d'une unité de travail (ISession) et de passer l'ISession dans les constructeurs de référentiel en tant que dépendance. De cette façon, une seule unité de travail peut enrôler autant de référentiels que nécessaire dans une transaction.