Accès à plus d'un fournisseur de données dans une couche de données

Question

Je travaille sur une application métier développée en utilisant la philosophie DDD. La base de données est accessible via NHibernate et la couche de données est implémentée en utilisant le modèle DAO.

Le diagramme de classes UML est illustré ci-dessous.

UML Class Diagram http://img266.imageshack.us/my.php?image=classdiagramhk0.png http://img266.imageshack.us/my.php?image=classdiagramhk0.png

Je ne sais pas la conception est bonne ou non. Qu'est-ce que tu penses?

Mais le problème n'est pas que la conception soit bonne ou pas. Le problème est après le démarrage de l'application d'une IDaoFactory est instancié dans la couche de présentation et envoyer en tant que paramètre aux classes de présentateur (qui est conçu en utilisant le modèle MVC) comme ci-dessous

... 
IDaoFactory daoFactory = new NHibernateDaoFactory(); //instantiation in main class 
... 
SamplePresenterClass s = new SamplePresenterClass(daoFactory); 
... 

utilisation d'un seul fournisseur de données (ce qui était une base de données) était simple. Mais maintenant nous devrions aussi obtenir des données de XML. Et les phases suivantes du développement nous devons nous connecter à différents services Web et manipuler les données entrantes et sortantes.

Les données de XML vont être obtenues en utilisant une clé qui est une énumération. Nous ajoutons une classe nommée XMLLoader à la couche de données et ajoutons une interface ILoader au domaine. XMLLoader a une méthode dont la signature est

List<string> LoadData(LoaderEnum key) 

Si nous instancier ILoader avec ChargeurXML dans la couche de présentation comme ci-dessous, nous devons l'envoyer à des objets qui va obtenir des données XML à partir de la couche de données.

ILoader loader = new XMLLoader(); 
SamplePresenterClass s = new SamplePresenterClass(daoFactory, xmlLoader); 

Après la mise en œuvre des classes d'accès aux services Web

SamplePresenterClass s = new SamplePresenterClass(daoFactory, xmlLoader, sampleWebServiceConnector1, sampleWebServiceConnector2, ...); 

Les paramètres va être cultivées dans le temps. Je pense que je peux tenir toutes les instances d'objets d'accès aux données dans une classe et les transmettre aux présentateurs requis (peut-être que le modèle singleton peut aussi aider). Dans la couche de domaine il doit y avoir une classe comme ça,

public class DataAccessHolder 
{ 
    private IDaoFactory daoFactory; 
    private ILoader loader; 
    ... 
    public IDaoFactory DaoFactory 
    { 
     get { return daoFactory; } 
     set { daoFactory = value; } 
    } 
    ... 
} 

En classe principale l'instanciation peut être fait avec cette conception comme suit

DataAccessHolder dataAccessHolder = new DataAccessHolder(); 
dataAccessHolder.DaoFactory = new NHibernateDaoFactory(); 
dataAccessHolder.Loader = new XMLLoader(); 
... 
SamplePresenterClass s = new SamplePresenterClass(dataAccessHolder); 

Que pensez-vous de cette conception ou pouvez-vous me suggérer un autre?

Merci pour tous les répliquants ...

Answer 1

OMI, il serait plus propre d'utiliser un « global » ou statique daoFactory et de le rendre générique.

DaoFactory<SamplePresenterClass>.Create(); // or 
DaoFactory<SamplePresenterClass>.Create(id); // etc 

Ensuite, vous pouvez définir DaoFactory<T> pour ne prendre que, par exemple, IDao « s

interface IDao 
{ 
    IDaoProvider GetProvider(); 
} 

interface IDaoProvider 
{ 
    IDao Create(IDao instance); 
    void Update(IDao instance); 
    void Delete(IDao instance); 
} 

Fondamentalement, au lieu de passer tous les constructeurs votre DaoFactory, vous utilisez un DaoFactory générique statique. Son T doit hériter de IDao.Ensuite, la classe DaoFactory peut regarder le fournisseur de T lors de l'exécution:

static class DaoFactory<T> where T : IDao, new() 
{ 
    static T Create() 
    { 
     T instance = new T(); 
     IDaoProvider provider = instance.GetProvider(); 

     return (T)provider.Create(instance); 
    } 
} 

Où IDaoProvier est une interface commune que vous mettre en œuvre pour charger les choses en utilisant XML, NHibernate, Web Services, etc. en fonction de la classe. (Chaque objet IDao saurait comment se connecter à son fournisseur de données).

Dans l'ensemble, ce n'est pas un mauvais design. Ajoutez un peu plus d'OO et vous aurez un joli design. Par exemple, chaque fichier pour le XmlEnums pourrait être mis en œuvre

de IDao

class Cat : IDao 
{ 
    IDaoProvider GetProvider() 
    { 
     return new XmlLoader(YourEnum.Cat); 
    } 

    // ... 
}