Overblog Suivre ce blog
Editer l'article Administration Créer mon blog

Présentation

  • : Romagny13 - Du .NET,du pur .NET
  • Romagny13 - Du .NET,du pur .NET
  • : Cycle de progression Faire (quelque chose qui marche) -> comprendre ce que l’on fait/comment cela marche -> pousser plus loin les notions
  • Contact

Recherche

Articles Récents

11 septembre 2007 2 11 /09 /septembre /2007 21:45
Enterprise Library – Repository (partie 1)


Document word complet(comprenant 3 parties)ici
sources ici

Avec Web Service Software Factory on dispose d’outils permettant de générer automatiquement toute ses entités métiers, sa couche accès aux données,etc. 
ce ‘est malheureusement pas le cas avec Enterprise Library même si RepositoryFactory pointe le bout de son nez
Cet article présente comment coder mais également les quelques nuances personnelles.
 
I partie generic – classes pouvant être réutilisées telles quelles dans tous projets (couche DataAccess)
II Création d’entités métiers (couche BusinessEntities)
III Classes de création de commandes (couche DataAccess)
IV Classes repository héritant de la classe abstraite généric Repository<TDomainObject> et implémentant leur interface (couche DataAccess)
V Repositories classe « façade » offrant un accès (static) à toutes les classes Repository de la couche DataAccess
VI couche présentation (fichier de configuration et exemple)

I la partie Generic
r1.JPG
C’est un peu le framework,c’est un ensemble d’interfaces,de classes que les classes que nous définirons devront respecter et pourront utiliser,
Ces classes pourront être utilisées « telles quelles » dans tous les projets
a-Interfaces qui devront être respectées par les classe de fabrication de commandes :
-          ISelectionFactory<TIdentity> : pour les commandes select
-          IInsertFactory <TDomainObject>: pour les commandes insert
-          IUpdateFactory<TDomainObject>: pour les commandes update
-          IDeleteFactory<TDomainObject>: pour les commandes delete
 
 
b-Repository<TDomainObject>
classe abstraite générique permettant d’exécuter n’importe quelle requête vers une base de données, toutes les classes en héritant utilisent donc ces méthodes (Find,FindOne,AddUpdate,Delete) pour lire ou mettre à jour la base de données
J’apporte une légère nuance personnelle pour les méthodes de mises à jour pour lesquels je retourne un entier
    public class Repository<TDomainObject>
    {
        private string databaseName;
        private Database db;
 
        public Repository(string databaseName)
        {
            this.databaseName = databaseName;
            this.db = DatabaseFactory.CreateDatabase(databaseName);
        }
 
          public List<TDomainObject> Find<TIdentity>(
            ISelectionFactory<TIdentity> selectionFactory,
            IDomainObjectFactory<TDomainObject> domainObjectFactory,
            TIdentity identity)
        {
            List<TDomainObject> results = new List<TDomainObject>();
 
            using (DbCommand command = selectionFactory.ConstructSelectCommand(db, identity))
            {
                using (IDataReader rdr = db.ExecuteReader(command))
                {
                    while (rdr.Read())
                    {
                        results.Add(domainObjectFactory.Construct(rdr));
                    }
                }
            }
            return results;
        }
 
        public TDomainObject FindOne<TIdentity>(
            ISelectionFactory<TIdentity> selectionFactory,
            IDomainObjectFactory<TDomainObject> domainObjectFactory,
            TIdentity identity)
        {
            TDomainObject result = default(TDomainObject);
            using (DbCommand command = selectionFactory.ConstructSelectCommand(db, identity))
            {
                using (IDataReader rdr = db.ExecuteReader(command))
                {
                    if (rdr.Read())
                    {
                        result = domainObjectFactory.Construct(rdr);
                    }
                }
            }
            return result;
        }
 
        public int Add(IInsertFactory<TDomainObject> insertFactory,
            TDomainObject domainObj)
        {
            using (DbCommand command = insertFactory.ConstructInsertCommand(db, domainObj))
            {
                int result = db.ExecuteNonQuery(command);
                insertFactory.SetNewID(db, command, domainObj);
                return result;
            }
        }
        public int Update(IUpdateFactory<TDomainObject> updateFactory, TDomainObject domainObj)
        {
            using (DbCommand command = updateFactory.ConstructUpdateCommand(db, domainObj))
            {
               return db.ExecuteNonQuery(command);
            }
        }
        public int Remove<TIdentityObject>(IDeleteFactory<TIdentityObject> deleteFactory,
            TIdentityObject identityObj)
        {
            using (DbCommand command = deleteFactory.ConstructDeleteCommand(db, identityObj))
            {
               return db.ExecuteNonQuery(command);
            }
        }    
    }

Partager cet article

Repost 0

commentaires