Che modello di progettazione per individuare il mio IUnitOfWork?

Question

Ho implementato un modello di repository con la persistenza ignoranza. L'implementazione repository interagisce solo con i miei oggetti entità, IUnitOfWork e ITable<T> interfacce. L'intenzione è che il IUnitOfWork non viene riutilizzato, ma rappresenta una singola transazione. Finora, ho implementato in memoria così come le versioni LINQ to SQL del IUnitOfWork e ITable<T>.

Il mio problema è che a causa della iniezione IUnitOfWork nel repository, io alla fine con la necessità di conoscere come creare un'istanza di una nuova IUnitOfWork dove mai viene utilizzato il repository. Dal momento che questo è il pezzo principale che si suppone essere pluggable ci si sente come ho fatto qualcosa di sbagliato. Lo schema generale di utilizzo è qualcosa di simile:

FooUnitOfWork unitOfWork = new FooUnitOfWork();
Repository repos = new Repository(unitOfWork);
// ...act upon repos
unitOfWork.Save();

Ora sembra che ho bisogno di qualche altro modello per consentire ogni uso repository in app per ottenere la corretta unità di lavoro (ad esempio in-memory, L2S, ecc.).

Qual è il modello più adatta per questo? Ho guardato la discussione di Fowler sul tema ma nessuno dei suoi esempi sembrano essere una misura pulita. Mi sento già come la quantità di astrazione che ho è di più di quanto mi piacerebbe così la costruzione di un altro riferimento indiretto sembra eccessivo.

Al momento, sto sporgendosi verso una sorta di fornitore a livello di applicazione, che può essere configurato in modo da produrre la IUnitOfWork corretta. Sono io off-base o si tratta di ciò che è necessario per essere veramente realizzazione agnostica?

Answer 1

Aggiornamento: mentre questo non ha veramente abbattere è finito per produrre un solo del povero uomo IoC Container. Ho finito appena sostituendo tutte queste:

UnitOfWorkFactory.Create();

implementazione Comune Service Locator :

Microsoft.Practices.ServiceLocation.ServiceLocator.Current.GetInstance<IUnitOfWork>();

Questo mi ha permesso di creare una libreria che utilizza Dependency Injection senza costringere tutti gli utenti di utilizzare lo stesso quadro CIO.

---

Forse dovrei utilizzare un semplicissimo fabbrica dove posso impostare una richiamata? Si potrebbe avere un insieme di metodi statici in questo modo:

public static class UnitOfWorkFactory
{
    private static Func<IUnitOfWork> FactoryMethod;

    public static IUnitOfWork Create()
    {
        if (UnitOfWorkFactory.FactoryMethod == null)
        {
            throw new InvalidOperationException("...");
        }

        return UnitOfWorkFactory.FactoryMethod();
    }

    public static void SetFactoryMethod(Func<IUnitOfWork> factory)
    {
        UnitOfWorkFactory.FactoryMethod = factory;
    }
}

Da dove viene questa abbattere?

Answer 2

Io suggerirei di usare un modello Vistor per scoprire le implementazioni dell'interfaccia IUnitOfWork.

[UnitOfWork(Name="foo")]
public class FooUnitOfWork : IUnitOfWork {}

Repository repo = new Repository("foo");
//stuff happens
repo.Save(); //or repo.Worker.Save();

All'interno l'istanza repo una fabbrica scoperta trova il lavoratore e lo crea.