Calendrier

Novembre 2009
L M M J V S D
            1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30            
<< < > >>

 

Présentation

 

Catégories

 

Articles récents

liste complète

 

Recherche

 

Liens

 

W3C

  • Flux RSS des articles

 

 

Enterprise Library

Enterprise Library – récupérer des paramètres de Procédures stockées

Enterprise Library –
récupérer des valeurs en retour de Procédures stockées
 
1 – solution : retourner un paramètre contenant une valeur (exemple l’identifiant d’une clé auto incrémentée)
CREATE PROCEDURE [dbo].[InsertContact]
(
     @ContactName char(100),
     @ContactFirstName char(100),
     @ContactAge int,@ContactCategoryID int
)
AS
declare @ContactID int;
INSERT INTO [Contact]([ContactName] ,[ContactFirstName] ,[ContactAge] ,[ContactCategoryID] )
VALUES(@ContactName,@ContactFirstName,@ContactAge,@ContactCategoryID)
SET @ContactID= SCOPE_IDENTITY();
return @ContactID;
 
Depuis enterprise Library
A-Création de la commande
public DbCommand ConstructInsertCommand(Database db,Contact Contact)
            {
                  DbCommand command = db.GetStoredProcCommand("dbo.AddContact");
                  db.AddInParameter(command, "ContactAge",DbType.Int32,Contact.ContactAge);
                  db.AddInParameter(command, "ContactCategoryID",DbType.Int32,Contact.ContactCategoryID);
                  db.AddInParameter(command, "ContactFirstName",DbType.String,Contact.ContactFirstName);
                  db.AddInParameter(command, "ContactName",DbType.String,Contact.ContactName);
                 db.AddParameter(command, "ContactID", DbType.Int32,ParameterDirection.ReturnValue,"ContactID",DataRowVersion.Default,null);
            return command;
            }
B – éxecution de la commande puis récupération du nouvel identifiant
        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 void SetNewID(Database db, DbCommand command, Contact domainObj)
       {
            domainObj.ContactID = (int)db.GetParameterValue(command, "ContactID");
       }
 
2- Autre solution : passer un paramètre OUT à la procédure stockée
CREATE PROCEDURE [dbo].[InsertContact]
(
      @ContactID int OUT,
      @ContactName char(100),
      @ContactFirstName char(100),
      @ContactAge int,@ContactCategoryID int
)
AS
INSERT INTO [Contact]([ContactName] ,[ContactFirstName] ,[ContactAge] ,[ContactCategoryID] )
VALUES(@ContactName,@ContactFirstName,@ContactAge,@ContactCategoryID);
/* affectation à la variable du nouvel identifiant (la column ContactID etant auto incrémentée */
SET @ContactID= SCOPE_IDENTITY();
 
 
 
Depuis enterprise Library
A-Création de la commande
public DbCommand ConstructInsertCommand(Database db,Contact Contact)
            {
                  DbCommand command = db.GetStoredProcCommand("dbo.AddContact");
                  db.AddInParameter(command, "ContactAge",DbType.Int32,Contact.ContactAge);
                  db.AddInParameter(command, "ContactCategoryID",DbType.Int32,Contact.ContactCategoryID);
                  db.AddInParameter(command, "ContactFirstName",DbType.String,Contact.ContactFirstName);
                  db.AddInParameter(command, "ContactName",DbType.String,Contact.ContactName);
                 db.AddOutParameter(command, "ContactID", DbType.Int32, 4);
            return command;
            }
      B – éxecution de la commande puis récupération du nouvel identifiant
        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 void SetNewID(Database db, DbCommand command, Contact domainObj)
       {
            domainObj.ContactID = (int)db.GetParameterValue(command, "ContactID");
       }
 
La seconde soltuion est peut être la mieux , en tout cas la plus utilisée

Note dans la méthode SetNewID j'affecte le nouvel identifiant,à mon objet métier (ici un contact) c'est à dire donc la valeur récupérée aprés execution de la procédure stockée
 
Par Romagny13
Ecrire un commentaire - Voir les 0 commentaires - Recommander

Enterprise Library – Repository – Commandes avec clés primaires sur plusieurs champs

Enterprise Library – Repository – Commandes avec clés primaires sur plusieurs champs

Exemple
1-Une classe identiy spécifique à la commande est créée
internal class GetEmployeeTerritoriesIdentity
    {
        public GetEmployeeTerritoriesIdentity(System.Int32 employeeID, System.String territoryID)
        {
            this.employeeIDField = employeeID;
            this.territoryIDField = territoryID;
 
        }
 
        private System.Int32 employeeIDField;
 
        public System.Int32 EmployeeID
        {
            get { return this.employeeIDField; }
            set { this.employeeIDField = value; }
        }
 
        private System.String territoryIDField;
 
        public System.String TerritoryID
        {
            get { return this.territoryIDField; }
            set { this.territoryIDField = value; }
        }
 
    }
 
2-Fabrique de la commande
internal class GetEmployeeTerritoriesSelectionFactory : ISelectionFactory<GetEmployeeTerritoriesIdentity>
    {
        
 
 public DbCommand ConstructSelectCommand(Database db, GetEmployeeTerritoriesIdentity getEmployeeTerritoriesIdentity)
        {
 
            DbCommand command = db.GetStoredProcCommand("dbo.GetEmployeeTerritories");
            db.AddInParameter(command, "EmployeeID", DbType.Int32, getEmployeeTerritoriesIdentity.EmployeeID);
            db.AddInParameter(command, "TerritoryID", DbType.String, getEmployeeTerritoriesIdentity.TerritoryID);
            return command;
        }
 
//…
}
 
3-Repository « typé »
-          On passe une instance de la classe entity pour la création des entités
public EmployeeTerritories GetEmployeeTerritories(System.Int32 employeeID, System.String territoryID)
        {
            ISelectionFactory<GetEmployeeTerritoriesIdentity> selectionFactory = new GetEmployeeTerritoriesSelectionFactory();
 
            try
            {
 
                GetEmployeeTerritoriesIdentity getEmployeeTerritoriesIdentity = new GetEmployeeTerritoriesIdentity(employeeID, territoryID);
                return base.FindOne(selectionFactory, new GetEmployeeTerritoriesFactory(), getEmployeeTerritoriesIdentity);
            }
            catch (SqlException ex)
            {
                HandleSqlException(ex, selectionFactory);
            }
 
            return new EmployeeTerritories();
        }
 
 
4-Méthode FindOne de Repository<TdomainObject>
L’instance de la classe identity passée est utilisée pour créer chaque instance objet/entité à partir du datareader
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;
        }
 
Pour une commande de type Delete , la démarche est exactement la même
Par Romagny13
Ecrire un commentaire - Voir les 0 commentaires - Recommander

Une classe d’expiration basée sur SqlDependency pour le cache d’Enterprise Library

Une classe d’expiration basée sur SqlDependency pour le cache d’Enterprise Library
 
    ///<summary>
    ///     This class tracks a SQL Server dependency.
    ///</summary>
    [Serializable]
    [ComVisible(false)]
    public class SqlServerDependency :ICacheItemExpiration
    {
        private bool isExpired;
 
        ///<summary>
        /// Get expiration state
        ///</summary>
        public bool IsExpired
        {
            get { return isExpired; }
        }
 
        ///<summary>
        /// Constructor with one argument.
        ///</summary>
        ///<param name="command"></param>
        public SqlServerDependency(SqlCommand command)
        {
            SqlDependency.Stop(command.Connection.ConnectionString);
            SqlDependency.Start(command.Connection.ConnectionString);
 
            command.Notification = null;
            SqlDependency sqlDependency = new SqlDependency(command);
            sqlDependency.OnChange += new OnChangeEventHandler(OnChanged);
 
            if (command.Connection.State == ConnectionState.Closed)
                command.Connection.Open();
 
            command.ExecuteReader(CommandBehavior.CloseConnection);
        }
 
        void OnChanged(object sender, SqlNotificationEventArgs e)
        {
            SqlDependency sqlDependency = sender as SqlDependency;
            sqlDependency.OnChange -= OnChanged;
            isExpired = true;
        }
        ///<summary>
        /// Specifies if the item has expired or not.
        ///</summary>
        ///<returns>Returns true if the item has expired, otherwise false.</returns>
        public bool HasExpired()
        {
            return isExpired;
        }
 
        ///<summary>
        /// Notifies that the item was recently used.
        ///</summary>
        public void Notify()
        {
        }
 
        ///<summary>
        /// Not used
        ///</summary>
        ///<param name="owningCacheItem">Not used</param>
        public void Initialize(CacheItem owningCacheItem)
        {
        }
    }
 
Exemple d’utilisation
CacheManager cacheManager = CacheFactory.GetCacheManager();
 
        private void button1_Click(object sender, EventArgs e)
        {
            DataSet dataSet=null;
            if (cacheManager.Contains("AllContacts"))
            {
                dataSet = (DataSet)cacheManager["AllContacts"];
                label1.Text = "from cache";
            }
            else
            {
                Database db = DatabaseFactory.CreateDatabase();
                DbCommand command = db.GetStoredProcCommand("dbo.GetAllContacts");
                dataSet = db.ExecuteDataSet(command);
                //
                SqlServerDependency dependency = new SqlServerDependency(
                    new SqlCommand("select ContactID,ContactName,ContactFirstName,ContactAge from dbo.Contact",
                    new SqlConnection((ConfigurationManager.GetSection("connectionStrings") as ConnectionStringsSection).ConnectionStrings[1].ConnectionString)
                        )
                    );
                cacheManager.Add("AllContacts", dataSet, CacheItemPriority.Normal, null, new ICacheItemExpiration[] { dependency });
                label1.Text = "from database";
            }
 
            dataGridView1.DataSource = dataSet.Tables[0];
        }

sqlserverdependency.JPG

La classe SqlServerDependency ici
Par Romagny13
Ecrire un commentaire - Voir les 0 commentaires - Recommander

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
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);
            }
        }    
    }
Par Romagny13
Ecrire un commentaire - Voir les 0 commentaires - Recommander

Enterprise Library - Repository (partie 2)

Enterprise Library - Repository (partie 2)


II Création des entités métiers
Ici dans la couche BusinessEntities
Exemple :
public class Contact
      {
            private int _ContactID;
 
            public int ContactID
            {
                  get { return _ContactID; }
                  set { _ContactID = value; }
            }
 
            private string _ContactName;
 
            public string ContactName
            {
                  get { return _ContactName; }
                  set { _ContactName = value; }
            }
 
            private string _ContactFirstName;
 
            public string ContactFirstName
            {
                  get { return _ContactFirstName; }
                  set { _ContactFirstName = value; }
            }
 
            private Nullable<int> _ContactAge;
 
            public Nullable<int> ContactAge
            {
                  get { return _ContactAge; }
                  set { _ContactAge = value; }
            }
 
            private int _ContactCategoryID;
 
            public int ContactCategoryID
            {
                  get { return _ContactCategoryID; }
                  set { _ContactCategoryID = value; }
            }
 
            public Contact()
            { }
 
            public Contact(int ContactID,string ContactName,string ContactFirstName,Nullable<int> ContactAge,int ContactCategoryID)
            {
                  this.ContactID = ContactID;
                  this.ContactName = ContactName;
                  this.ContactFirstName = ContactFirstName;
                  this.ContactAge = ContactAge;
                  this.ContactCategoryID = ContactCategoryID;
            }
 
        public override string ToString()
        {
            return "Name : " + ContactName + "rFirstname : " + ContactFirstName + (ContactAge.HasValue ? "rAge : " + ContactAge : string.Empty) + "rCategory : " + ContactCategoryID.ToString();
        }
      }
 
III Classes de création des commandes
-          Celles-ci implémentent toutes une interface liée à la création commandes(ISelectionFactory<TIdentity> ,IInsertFactory <TDomainObject>,IUpdateFactory<TDomainObject>,IDeleteFactory<TDomainObject>)
  r2.JPG
Exemple avec la classe Contact
    internal class GetAllContactsSelectionFactory : ISelectionFactory<NullableIdentity>
    {
        public DbCommand ConstructSelectCommand(Database db, NullableIdentity nullableIdentity)
        {
            DbCommand command = db.GetStoredProcCommand("dbo.GetAllContacts");
            return command;
        }
 
        public string MapDbParameterToBusinessEntityProperty(string dbParameter)
        {
            switch (dbParameter)
            {
                default:
                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, GenericResources.InvalidParameterName), dbParameter);
            }
        }
    }
    internal class GetContactsOfCategorySelectionFactory : ISelectionFactory<int>
    {
        public DbCommand ConstructSelectCommand(Database db, int contactCategoryID)
        {
            DbCommand command = db.GetStoredProcCommand("dbo.GetContactsOfCategory");
            db.AddInParameter(command, "ContactCategoryID", DbType.Int32, contactCategoryID);
            return command;
        }
        public string MapDbParameterToBusinessEntityProperty(string dbParameter)
        {
            switch (dbParameter)
            {
                case "ContactCategoryID":
                    return "ContactCategoryID";
                default:
                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, GenericResources.InvalidParameterName), dbParameter);
            }
        }
    }
    internal class GetContactSelectionFactory : ISelectionFactory<int>
    {
        public DbCommand ConstructSelectCommand(Database db, int contactID)
        {
 
            DbCommand command = db.GetStoredProcCommand("dbo.GetContact");
            db.AddInParameter(command, "ContactID", DbType.Int32, contactID);
            return command;
        }
        public string MapDbParameterToBusinessEntityProperty(string dbParameter)
        {
            switch (dbParameter)
            {
                case "ContactID":
                    return "ContactID";
                default:
                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, GenericResources.InvalidParameterName), dbParameter);
            }
        }
    }
    internal class ContactInsertFactory : IDbToBusinessEntityNameMapper, IInsertFactory<Contact>
    {
       public DbCommand ConstructInsertCommand(Database db, Contact contact)
        {
            DbCommand command = db.GetStoredProcCommand("dbo.AddContact");
            db.AddInParameter(command, "ContactName", DbType.String, contact.ContactName);
            db.AddInParameter(command, "ContactFirstName", DbType.String, contact.ContactFirstName);
            if (contact.ContactAge.HasValue)
                db.AddInParameter(command, "ContactAge", DbType.Int32, contact.ContactAge);
            else
                db.AddInParameter(command, "ContactAge", DbType.Int32, DBNull.Value);
            db.AddInParameter(command, "ContactCategoryID", DbType.String, contact.ContactCategoryID);
 
            return command;
        }
        public void SetNewID(Database db, DbCommand command, Contact contact)
        {
 
        }
        public string MapDbParameterToBusinessEntityProperty(string dbParameter)
        {
            switch (dbParameter)
            {
                case "ContactAge":
                    return "ContactAge";
                case "ContactCategoryID":
                    return "ContactCategoryID";
                case "ContactFirstName":
                    return "ContactFirstName";
                case "ContactName":
                    return "ContactName";
                default:
                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, GenericResources.InvalidParameterName), dbParameter);
            }
        }
    }
    internal class ContactUpdateFactory : IDbToBusinessEntityNameMapper, IUpdateFactory<Contact>
    {
        public DbCommand ConstructUpdateCommand(Database db, Contact contact)
        {
            DbCommand command = db.GetStoredProcCommand("dbo.UpdateContact");
            db.AddInParameter(command, "ContactID", DbType.String, contact.ContactID);
            db.AddInParameter(command, "ContactName", DbType.String, contact.ContactName);
            db.AddInParameter(command, "ContactFirstName", DbType.String, contact.ContactFirstName);
            if (contact.ContactAge.HasValue)
                db.AddInParameter(command, "ContactAge", DbType.Int32, contact.ContactAge);
            else
                db.AddInParameter(command, "ContactAge", DbType.Int32, DBNull.Value);
            db.AddInParameter(command, "ContactCategoryID", DbType.String, contact.ContactCategoryID);
 
            return command;
 
        }
        public string MapDbParameterToBusinessEntityProperty(string dbParameter)
        {
            switch (dbParameter)
            {
                case "ContactAge":
                    return "ContactAge";
                case "ContactCategoryID":
                    return "ContactCategoryID";
                case "ContactFirstName":
                    return "ContactFirstName";
                case "ContactID":
                    return "ContactID";
                case "ContactName":
                    return "ContactName";
                default:
                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, GenericResources.InvalidParameterName), dbParameter);
            }
        }
    }
   internal class ContactDeleteFactory : IDeleteFactory<int>
    {
        public DbCommand ConstructDeleteCommand(Database db, int contactID)
        {
            DbCommand command = db.GetStoredProcCommand("dbo.DeleteContact");
            db.AddInParameter(command, "ContactID", DbType.Int32, contactID);
            return command;
        }
        public string MapDbParameterToBusinessEntityProperty(string dbParameter)
        {
            switch (dbParameter)
            {
                case "ContactID":
                    return "ContactID";
                default:
                    throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, GenericResources.InvalidParameterName), dbParameter);
            }
        }
    }
 
Par Romagny13
Ecrire un commentaire - Voir les 0 commentaires - Recommander

Enterprise Library - Repository (partie 3)

Enterprise Library - Repository (partie 3)


IV Repository 
r3.JPG
 
Toujours avec Contact pour exemple
On crée une interface listant les méthodes qui devront être implémenté
public interface IContactRepository
    {
        List<Contact> GetAllContacts();
        List<Contact> GetContactsOfCategory(int categoryID);
        Contact GetContact(int contactID);
        int AddContact(Contact contact);
        int UpdateContact(Contact contact);
        int RemoveContact(int contactID);
    }
 
La classe hérite de Repository<TDomainObject> et implémente son interface
public class ContactRepository : Repository<Contact>,IContactRepository
    {
        public ContactRepository(string databaseName)
            : base(databaseName)
        {
        }
 
        public List<Contact> GetAllContacts()
        {
            ISelectionFactory<NullableIdentity> selectionFactory = new GetAllContactsSelectionFactory();
 
            try
            {
                NullableIdentity nullableIdentity = new NullableIdentity();
                return Find(selectionFactory, new ContactFactory(), nullableIdentity);
            }
            catch (SqlException ex)
            {
                HandleSqlException(ex, selectionFactory);
            }
          
            return new List<Contact>();
        }
        public List<Contact> GetContactsOfCategory(int contactCategoryID)
        {
            ISelectionFactory<int> selectionFactory = new GetContactsOfCategorySelectionFactory();
            try
            {
                return Find<int>(selectionFactory, new ContactFactory(), contactCategoryID);
            }
            catch (SqlException ex)
            {
                HandleSqlException(ex, selectionFactory);
            }
            return new List<Contact>();
        }
        public Contact GetContact(int contactID)
        {
            ISelectionFactory<int> selectionFactory = new GetContactSelectionFactory();
            try
            {
                return FindOne(selectionFactory, new ContactFactory(), contactID);
            }
            catch (SqlException ex)
            {
                HandleSqlException(ex, selectionFactory);
            }
            return new Contact();
        }
        public int AddContact(Contact contact)
        {
            IInsertFactory<Contact> insertFactory = new ContactInsertFactory();
            try
            {
                return Add(insertFactory, contact);
            }
            catch (SqlException ex)
            {
                HandleSqlException(ex, insertFactory);
            }
            return 0;
        }
        public int UpdateContact(Contact contact)
        {
            IUpdateFactory<Contact> updateFactory = new ContactUpdateFactory();
            try
            {
                return Update(updateFactory, contact);
            }
            catch (SqlException ex)
            {
                HandleSqlException(ex, updateFactory);
            }
            return 0;
        }
        public int RemoveContact(int contactID)
        {
            IDeleteFactory<int> deleteFactory = new ContactDeleteFactory();
            try
            {
                return Remove(deleteFactory, contactID);
            }
            catch (SqlException ex)
            {
                HandleSqlException(ex, deleteFactory);
            }
            return 0;
        }
        private void HandleSqlException(SqlException ex, IDbToBusinessEntityNameMapper mapper)
        {
            if (ex.Number == ErrorCodes.SqlUserRaisedError)
            {
                switch (ex.State)
                {
                    case ErrorCodes.ValidationError:
                        string[] messageParts = ex.Errors[0].Message.Split(':');
                        throw new RepositoryValidationException(
                            mapper.MapDbParameterToBusinessEntityProperty(messageParts[0]),
                            messageParts[1], ex);
 
                    case ErrorCodes.ConcurrencyViolationError:
                        throw new ConcurrencyViolationException(ex.Message, ex);
 
                }
            }
            throw new RepositoryFailureException(ex);
        }
    }
 
J’utilise une et une seule fabrique pour la création d’instances à partir d’un datareader
Exemple ici ContactFactory
internal class ContactFactory : IDomainObjectFactory<Contact>
    {
        public Contact Construct(System.Data.IDataReader reader)
        {
            Contact contact = new Contact();
 
            contact.ContactID = Convert.ToInt32(reader["ContactID"]);
            contact.ContactName = Convert.ToString(reader["ContactName"]);
            contact.ContactFirstName = Convert.ToString(reader["ContactFirstName"]);
 
            if (reader["ContactAge"] != DBNull.Value)
                contact.ContactAge = Convert.ToInt32(reader["ContactAge"]);
            contact.ContactCategoryID = Convert.ToInt32(reader["ContactCategoryID"]);
 
            return contact;
        }
    }
 
V Création d’une «classe façade » Repositories
Ici dans la couche BusinessLogic, c’est avec cette classe que la couche présentation dialoguera
public static class Repositories
    {
        private const string databaseName = "ContactDBConnectionString";
        private static IContactRepository contactRepository = new ContactRepository(databaseName);
        private static ICategoryRepository categoryRepository = new CategoryRepository(databaseName);
 
        public static IContactRepository Contacts
        {
            get { return contactRepository; }
        }
 
        public static ICategoryRepository Categories
        {
            get { return categoryRepository; }
        }
    }
 
VI Couche présentation
Le fichier de configuration peut être au plus simple :
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
      <connectionStrings>
            <add name="ContactDBConnectionString"
                  connectionString="Data Source=.SQLEXPRESS;AttachDbFilename=|DataDirectory|ContactDB.mdf;Integrated Security=True;User Instance=True" providerName="System.Data.SqlClient"/>
      </connectionStrings>
</configuration>
 
Exemple de code
       private void button1_Click(object sender, EventArgs e)
        {
            List<Contact> contacts = Repositories.Contacts.GetAllContacts();
            dataGridView1.DataSource = contacts;
        }
 
 
Par Romagny13
Ecrire un commentaire - Voir les 0 commentaires - Recommander

Bonne pratique – Créer un objet à partir d’un datareader par l’intermédiaire d’une fabrique

Bonne pratique – Créer un objet à partir d’un datareader par l’intermédiaire d’une fabrique

L’exemple ici est avec Enterprise Library,mais cette technique est également utilisée par CodeFluent par exemple, à n'en pas douter une pratique à utiliser dans tous ses projets (avec ou sans Enterprise Library)
    public class ContactFactory
    {
        public Contact Create(IDataReader reader)
        {
            Contact contact = new Contact();
 
            contact.ContactID = Convert.ToInt32(reader["ContactID"]);
            contact.ContactName = Convert.ToString(reader["ContactName"]);
            contact.ContactFirstName = Convert.ToString(reader["ContactFirstName"]);
 
            if (reader["ContactAge"] != DBNull.Value)
                contact.ContactAge = Convert.ToInt32(reader["ContactAge"]);
            contact.ContactCategoryID = Convert.ToInt32(reader["ContactCategoryID"]);
           
            return contact;
        }
    }
 
Business Object
      public class Contact
      {
            private int _ContactID;
 
            public int ContactID
            {
                  get { return _ContactID; }
                  set { _ContactID = value; }
            }
 
            private string _ContactName;
 
            public string ContactName
            {
                  get { return _ContactName; }
                  set { _ContactName = value; }
            }
 
            private string _ContactFirstName;
 
            public string ContactFirstName
            {
                  get { return _ContactFirstName; }
                  set { _ContactFirstName = value; }
            }
 
            private Nullable<int> _ContactAge;
 
            public Nullable<int> ContactAge
            {
                  get { return _ContactAge; }
                  set { _ContactAge = value; }
            }
 
            private int _ContactCategoryID;
 
            public int ContactCategoryID
            {
                  get { return _ContactCategoryID; }
                  set { _ContactCategoryID = value; }
            }
 
            public Contact()
            { }
           
      }
 
Depuis la classe d’accès aux données (DAO)
        public List<Contact> GetContacts()
        {
            List<Contact> contacts = new List<Contact>();
 
            ContactFactory contactFactory = new ContactFactory();
 
            DbCommand command = db.GetStoredProcCommand("GetContacts");
 
            using (IDataReader reader = db.ExecuteReader(command))
            {
                while (reader.Read())
                    contacts.Add(contactFactory.Create(reader));
            }
 
            return contacts;
        }
 
Il est également possible de définir une interface pour la fabrique et même utiliser les generics pour .NET 2.0
    public interface IDomainObjectFactory<TDomainObject>
    {
        TDomainObject Create(IDataReader reader);
    }
    public class ContactFactory : IDomainObjectFactory <Contact>
    {
    }
    public class CategoryFactory : IDomainObjectFactory <Category>
    {
    }

  readerpractice-copie-1.JPG
Par Romagny13
Ecrire un commentaire - Voir les 0 commentaires - Recommander

CodeSmith + NetTiers

CodeSmith + NetTiers  + Enterprise Library

Build a Data Access Layer in less than 15 minutes

http://www.codeproject.com/showcase/CodeSmith.asp 

pour générer tout son code d'accès aux données avec Enterprise Library rapidement
Par Romagny13
Ecrire un commentaire - Voir les 0 commentaires - Recommander
Créer un blog sur over-blog.com - Contact - C.G.U. - Rémunération en droits d'auteur - Signaler un abus