Unità di lavoro di più sorgenti dati?

Question

E 'possibile (anche probabile) che io sono solo, non Grokking pienamente il concetto di una "unità di lavoro". Fondamentalmente, vedo come una sorta di ampio transazione utilizzato in un ambiente orientato agli oggetti. Avviare l'unità di lavoro, interagire con gli oggetti, commit o indietro rotolo. Ma come funziona questa rottura verso il basso per le transazioni effettive sulla memorizzazione dei dati che stanno dietro quegli oggetti?

In un sistema con un unico DB e un ORM (come NHibernate) è facile. L'operazione può essere mantenuta attraverso l'ORM. Ma che dire di un sistema in cui i modelli di dominio personalizzato sono oscurando molte fonti di dati disparate? E non tutte queste fonti di dati sono database relazionali? (C'è un sacco fatto sul file system da queste parti).

In questo momento mi sono bloccato sull'idea che "semplicemente non si può mantenere una transazione attraverso uno SQL2005 DB, uno SQL2000 DB, un DB2 DB, e il file system tutti nella stessa operazione di business 'atomica'." Quindi per ora è la responsabilità degli sviluppatori del team (che in genere lavorano indipendentemente l'uno dall'altro) per mantenere le operazioni manualmente nel codice. Ogni DB può avere transazioni corrette su di esso, ma l'operazione di business nel suo complesso è controllato ed equilibrato ogni significativo passo del cammino manualmente.

Tuttavia, con la crescente complessità del fatturato dominio e sviluppatore di serie, questo approccio diventerà sempre più difficile e soggetto ad errori nel corso del tempo.

Qualcuno ha qualche consiglio o esempi di come un dominio del genere potrebbe essere meglio indirizzata, o come è stato affrontato prima? Il "dominio" attuale in questo caso è ancora molto nella sua infanzia, in continua evoluzione come prototipo a un giorno espandere e consumare / sostituzione di un vasto ecosistema di applicazioni legacy disparate. Quindi c'è un sacco di spazio per la ri-progettazione e ri-factoring.

Per avere un riferimento, una vista da 10.000 piedi del disegno Attualmente sto puntando è: Una grande raccolta di piccolo-dumb-come-possibile applicazioni client che richiedono un servizio centrale basata su messaggi. Il servizio è la porta d'ingresso nel "core dominio" e può essere pensato come un unico grande applicazione in stile MVC. Le richieste sono fatte per il servizio (molto simile a "azioni") che vengono raccolti da gestori (molto simile a "controllori"). Tutto ciò procedurale va là. Essi interagiscono con i modelli, che contengono tutte le regole di business. I modelli pubblicano eventi che ascoltatori ( "servizi"? Questa parte è ancora nuvoloso al design e al miglioramento di) raccogliere e maniglia interagendo con gli archivi (database di x, y di database, file system, e-mail, qualsiasi risorsa esterna). Tutti allegramente la dipendenza-iniettato di conseguenza.

Ci scusiamo per tutta la prolissità :) Ma se qualcuno ha qualche consiglio, mi piacerebbe sentirlo. Anche (soprattutto) se questo consiglio è "il disegno è male, provate questo invece ..." Grazie!

Answer 1

In precedenza ho lavorato su un sistema che potrebbe raggiungere questo obiettivo, ed è abbastanza semplice. Dal momento che progetto è nella sua fase iniziale, forse questo potrebbe essere informazioni utili per voi. Purtroppo, non ho più accesso al codice, ma sono comunque confortevole nel descrivere come funzionava.

Quello che avevo fatto è stato costruito il mio repository utilizzando un'implementazione modello repository generico. Il tipo di repository di base sarebbe sempre i riferimenti da parte dei servizi e UOW. Per l'amor di discussione, lo chiameremo BaseRepository. "T" si sarebbe limitato a implementazioni IEntity, che denotavano un oggetto di dominio. Dal BaseRepository, avevo creato un altro set di classi di base per la composizione, come ad esempio SqlBaseRepository, XmlBaseRepository, ecc.

L'UoW preoccupa solo che qualcosa è del tipo BaseRepository, che è dove la funzionalità di base esisterebbe. Base CUD (di CRUD) sarebbe rappresentato, fornendo gli equivalenti per crea, aggiornamenti ed eliminazioni. Quello che ognuno di questi sarebbe fare sarebbe quello di creare un delegato e metterlo in una coda all'interno del UoW, passando anche lungo le informazioni su ciò che tipo di transazioni che stava per essere, e i dati appropriati necessario per completarlo. L'UoW inizierebbe il mantenimento di un elenco di ciò che i repository sono stati avranno bisogno di essere coinvolto nella transazione, ma ancora non importava che tipo fosse. Effictively, fare la fila qui è come arruolarsi in una transazione.

Il BaseRepository definito un metodo astratto chiamato qualcosa come .ApplyChange (). Una volta .Commit () è stato chiamato sul UoW, creerebbe un TransactionScope () e iniziare a chiamare le delagates nella lista, passando di nuovo le informazioni per .ApplyChange (). La realizzazione delle .ApplyChange () esiste nella specifica base repository, cioè lo SqlRepositoryBase, ecc e potrebbe essere sostituito dal attuazione, pure.

dove ha ottenuto difficile, almeno per me, stava rotolando indietro. Ho affrontato solo con un unico database, ma a volte ha avuto cambiamenti basati su file che sono state fatte. Ho aggiunto un .RevertChange () e gli stati di monitoraggio dello stato originale iniziate e modificati in modo che potessi fondamentalmente applicare un reverse-delta per tornare a dove mi trovavo sulla pila di file.

Vorrei che avrei potuto essere più specifico sulla realizzazione, ma è stato più di un anno da quando ho visto il codice ora. Posso dirvi che la base per il codice originale è stato sostenuto dal libro, NET Dominio Driven design con C #: Problem - design - Solution , da Tim McCarthy. Una grande quantità di mia implementazione repository era basata sui suoi esempi, con una larga maggioranza del mio personalizzazione proveniva dalla UoWs e la loro attuazione.

Mi auguro che aiuta, un po '! : -)