Implementazione UnitOfWork

Question

Sono stato in grado di implementare una piccola unità di lavoro per lavorare con il framework di entità.

mi si avvicinò con ..

public class UnitOfWork : IUnitOfWork 
    { 
     private Database _database; 
     private IDatabaseFactory _databaseFactory; 

     private DbTransaction transaction; 

     public UnitOfWork(IDatabaseFactory databaseFactory) 
     { 
      _databaseFactory = databaseFactory; 
      _database = Database; 

      transaction = _database.Database.Connection.BeginTransaction(); 
     } 

     public Database Database 
     { 
      get { return _database ?? (_database = _databaseFactory.Get()); } 
     } 

     public void Dispose() 
     { 
      try 
      { 
       _database.SaveChanges(); 
       transaction.Commit(); 
      } 
      catch (Exception ex) 
      { 
       transaction.Rollback(); 
      } 
     } 
    } 

Sono abbastanza sicuro che ognuno è geloso di questa unità di lavoro ora. (Scherzando)

Ma ho un piccolo problema di progettazione in questo livello di servizio.

public class JournalService : IJournalService 
    { 
     IJournalRepository _journalRepository; 

     public JournalService(IJournalRepository journalRepository) 
     { 
      _journalRepository = journalRepository; 
     } 

     public void AjouterJournal(Journal j) 
     { 
      [B]using (IUnitOfWork uow = new UnitOfWork())[/B] 
      { 
       var journal = new Journal(); 
       journalRepository.AddJournal(journal); 

      } 
     } 
    } 

Il problema è che l'unità di lavoro necessita di un'iniezione di database quindi non posso crearne un'istanza. Non posso fornire un'unità di lavoro direttamente nel livello di servizio perché non avrebbe senso poiché l'unità di lavoro deve essere eliminabile.

E poiché utilizzo il repository per aggiungere la mia roba non è necessario accedere direttamente all'unità di lavoro, il salvataggio avverrà automaticamente quando verrà comunque eliminato.

Potrei iniettare IDatabaseFactory nel mio livello di servizio ma l'idea è di non usarlo lì. In realtà il livello di servizio non dovrebbe saperlo.

Che ne dici di una fabbrica UnitOfWork?

Qualche idea o suggerimento su come posso risolvere questo problema?

Grazie.

Answer 1

È necessario immettere UnitOfWork in servizio se si desidera utilizzare l'architettura corrente. Il tuo servizio non avrà una dipendenza interna (nascosta) dall'implementazione di UnitOfWork e sarà meglio verificabile. Va di pari passo con molti principi dell'architettura orientata agli oggetti.

Un'altra cosa è che questa implementazione è utilizzabile solo per semplici operazioni CRUD. In servizi più complessi si finirà con la composizione di più operazioni (possibilmente da servizi multipe) che funzioneranno ciascuna con UnitOfWork. Chiamare più SaveChanges (e transazioni) in un'unica operazione commerciale probabilmente non è ciò che si vuole normalmente: in tal caso, si desidera chiamare SaveChanges solo una volta da un servizio di primo livello o dal chiamante del servizio. Lo scenario tipico è che la singola operazione commerciale ha una unità di lavoro con una transazione, ma è possibile eseguire molte operazioni del servizio come parte di questa operazione aziendale.

Un'altra implicazione è la costruzione dei tuoi archivi. Probabilmente hanno bisogno di accedere al Database, vero? Quindi probabilmente stai già iniettando UoW nel costruttore del repository. Se lo fai, puoi evitare la relazione tra UoW e i servizi di base.