Enterprise Library – Repository (partie 1)

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

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);

            }

        }    

    }