Implementa un quadro di persistenza con Iniezione di dipendenza

Attualmente sto lavorando a un'applicazione Web a più livelli utilizzando l'API Web ASP.NET 2. È stato deciso di utilizzare il boilerplate come framework DI. Ora, ho bisogno di riconsiderare l'architettura che lega il livello aziendale al livello di persistenza. L'architettura attuale utilizza una Persistence Facade che espone le operazioni di scrittura / lettura del database ( Applicazione di UML e Pattern di Craig Larman).

public class PersistenceFacade
{
    //AS SINGLETON

    private static PersistenceFacade _istance = null;

    protected PersistenceFacade()
    {
        mappers = new Dictionary<string, IRelationalDBMapper>();
        mappers.Add("AnnotatoDto", new AnnotatiRDBMapper());
        mappers.Add("AppuntatoRequestDto", new AppuntatiRDBMapper());
    }

    public static PersistenceFacade GetIstance()
    {
       ... return Singleton Istance...
    }

    //AS CLASS

    Dictionary<string, IRelationalDBMapper> mappers;

    public Object Get(OID oid, string persistenceClass)
    {
        IRelationalDBMapper mapper = (IRelationalDBMapper)mappers[persistenceClass];
        return mapper.Get(oid);
    }

    public bool Put(OID oid, Object obj)
    {... mapper.Put(oid, obj);}

    public bool Delete(OID oid, Object obj)
    {... mapper.Put(oid, obj);}

}

Ora l'interfaccia Mapper riassume come le DTO sono mappate agli oggetti db

public interface IRelationalDBMapper
{

    Object Get(OID oid);

    bool Put(OID oid, Object obj);

    bool Delete(OID oid, Object obj);
}

questa interfaccia è implementata da:

public class FooRDBMapper : IRelationalDBMapper
{
    IDocumentStoreService _dbConnector;

    public AppuntatiRDBMapper()
    {
        _dbConnector = IocManager.Instance.Resolve<IDocumentStoreService>();
    }

    public object Get(OID oid)
    {...}

    public bool Put(OID oid, object obj)
    {...
        _dbConnector.AddAppuntato(oid, appuntato)...
    }

    public bool Delete(OID oid, Object obj)
    {
        ..._dbConnector.DeleteAppuntato(userOid, appuntato);...
    }
}

e

BarRDBMapper : IRelationalDBMapper{
    ...similar to FooRDBMapper...
}

Infine, ho una classe App Domain:

public class UserNavigationService{

    ...

    AddFoo(UserOID oid, Foo foo){

        return PersistenceFacade.GetIstance().Put(oid, foo);
    }
    ...other methods like: DeleteFoo, AddBar, GetBar  ecc.....
}

Quello che voglio ottenere è smontare questo Pattern, dal momento che ho bisogno di usare DI per Inject a PersistenceFacade alcune dipendenze (IConfigurationService, IPathTranslator ecc ...). L'uso di DI mi costringe a riconsiderare l'intera faccenda. Voglio un'architettura che in UserNavigationService mi permetta di scrivere:

...
IPersistenceService<IDocumentService> _dbService;

public UserNavigationService(IPersistenceService<IDocumentService> dbService, ...){
    ...
}

AddFoo(UserOID oid, Foo foo){
    return _dbService.Put<FooDTO>(oid, foo);
}

In particolare, ho bisogno di fare due astrazioni: che tipo di database (Oracle, MongoDB, file XML) e che tipo di oggetto (Foo, Bar). Non riesco davvero a capire come fare.

Ho un IDocumentStoreService, che è un'interfaccia che espone tutti i metodi per archiviare / raccogliere tutti i dati da tutti i vari database. (Ho bisogno di questa astrazione dal momento che sto per migrare ad un altro database relazionale). Una classe di implementazione di questa interfaccia potrebbe essere ThatDBDocumentService.