Media-ap | Architecture n-tiers

Architecture n-tiers

Le but du développement n-tiers est de :

faciliter la maintenance de l'application
rendre l'accès aux données indépendant de notre application directement. Un changement de type de BDD est simplifié, plus besoin de tout refaire
faciliter la coopération et l'indépendance des membres de l'équipe: le graphiste peut travailler tranquillement sur la couche cliente sans rentrer dans du code complexe
Lisibilité du code
Réutilisabilité du code
Indépendance vis à vis de l'interface utilisée : une application winform ou une applicatin web peuvent aussi bien être relié à la couche métier.

Une application n-tiers est en général composée de 4 couches:

BLL : Business Logic Layer
DAL: Data Access Layer
BO: Business Object
UI: User interface

A ces 4 couches il convient d'ajouter une couche tools qui permet de regrouper les outils transversaux nécessaires à l'application et qui peuvent être utiliser par les différentes couches.

L'interface cliente

Elle permet de mettre en forme et de permettre au client de visualiser une liste de compte par exemple.
Elle ne contient donc pas de traitement métier ni d'accès direct à notre base de données

Les Business Object

Si on a par exemple une application qui gère des comptes clients on aura un BO Accounts
Un Client a un identifiant, un nom, un prénom, une adresse ...

exemple:

public class ACCOUNTS
    {
        private int _ID_ACCOUNT;

        public int ID_ACCOUNT
        {
            get { return _ID_ACCOUNT; }
            set { _ID_ACCOUNT = value; }
        }

        private string _NAME;

        public string NAME
        {
            get { return _NAME; }
            set { _NAME = value; }
        }

        private string _FIRST_NAME;

        public string FIRST_NAME
        {
            get { return _FIRST_NAME; }
            set { _FIRST_NAME = value; }
        }

        private int _ID_COUNTRY;

        public int ID_COUNTRY
        {
            get { return _ID_COUNTRY; }
            set { _ID_COUNTRY = value; }
        }

        private string _EMAIL_ADDRESS;

        public string EMAIL_ADDRESS
        {
            get { return _EMAIL_ADDRESS; }
            set { _EMAIL_ADDRESS = value; }
        }

        private string _PHONE_NUMBER;

        public string PHONE_NUMBER
        {
            get { return _PHONE_NUMBER; }
            set { _PHONE_NUMBER = value; }
        }

               public ACCOUNTS()
        { }

        public ACCOUNTS(int ID_ACCOUNT,string NAME,string FIRST_NAME,int ID_COUNTRY,string EMAIL_ADDRESS,string PHONE_NUMBER)
        {
            this.ID_ACCOUNT = ID_ACCOUNT;
            this.NAME = NAME;
            this.FIRST_NAME = FIRST_NAME;
            this.ID_COUNTRY = ID_COUNTRY;
            this.EMAIL_ADDRESS = EMAIL_ADDRESS;
            this.PHONE_NUMBER = PHONE_NUMBER;
        }




            #endregion
        }
    }

.....

Typiquement on peut dire qu'on a un objet par table (BDD) significatif.

Data Access Layer

Dans cette partie on gère l'accès aux données

exemple de classe
public class ACCOUNTSDAO
    {
        public ACCOUNTSDAO()
        {
            DbProviderHelper.GetConnection();
        }
        public List<ACCOUNTS> GetACCOUNTSs()
        {
            try
            {
                List<ACCOUNTS> lstACCOUNTSs = new List<ACCOUNTS>();
                DbCommand oDbCommand = DbProviderHelper.CreateCommand("SELECT [ID_ACCOUNT],[NAME],[FIRST_NAME],[ID_COUNTRY],[EMAIL_ADDRESS],[PHONE_NUMBER]",CommandType.Text);
                DbDataReader oDbDataReader = DbProviderHelper.ExecuteReader(oDbCommand);
                while (oDbDataReader.Read())
                {
                    ACCOUNTS oACCOUNTS = new ACCOUNTS();
                    oACCOUNTS.ID_ACCOUNT = Convert.ToInt32(oDbDataReader["ID_ACCOUNT"]);

                    if(oDbDataReader["NAME"] != DBNull.Value)
                        oACCOUNTS.NAME = Convert.ToString(oDbDataReader["NAME"]);

                    if(oDbDataReader["FIRST_NAME"] != DBNull.Value)
                        oACCOUNTS.FIRST_NAME = Convert.ToString(oDbDataReader["FIRST_NAME"]);
                    oACCOUNTS.ID_COUNTRY = Convert.ToInt32(oDbDataReader["ID_COUNTRY"]);

                    if(oDbDataReader["EMAIL_ADDRESS"] != DBNull.Value)
                        oACCOUNTS.EMAIL_ADDRESS = Convert.ToString(oDbDataReader["EMAIL_ADDRESS"]);

                    if(oDbDataReader["PHONE_NUMBER"] != DBNull.Value)
                        oACCOUNTS.PHONE_NUMBER = Convert.ToString(oDbDataReader["PHONE_NUMBER"]);
                    oACCOUNTS.ID_MOBILE = Convert.ToInt32(oDbDataReader["ID_MOBILE"]);
                    oACCOUNTS.ID_PROVIDER = Convert.ToInt32(oDbDataReader["ID_PROVIDER"]);




                    lstACCOUNTSs.Add(oACCOUNTS);
                }
                oDbDataReader.Close();
                return lstACCOUNTSs;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

Business Logic Layer:

Dans la BLLon va mettre les opérations et traitement qui concerne notre métier. Il ne faut pas mettre ces traitements dans la couche DAL car elle concerne uniquement l'accès aux données (Select, Insert, Update, delete)

La couche BLL va servir à faire le lien entre la DAL et IU (L'interface cliente)

exemple de code

public class ACCOUNTSBLL
    {
        private ACCOUNTSDAO _ACCOUNTSDAO;

        public ACCOUNTSDAO ACCOUNTSDAO
        {
            get { return _ACCOUNTSDAO; }
            set { _ACCOUNTSDAO = value; }
        }

        public ACCOUNTSBLL()
        {
            ACCOUNTSDAO = new ACCOUNTSDAO();
        }
        [System.ComponentModel.DataObjectMethodAttribute(System.ComponentModel.DataObjectMethodType.Select, true)]
        public List<ACCOUNTS> GetACCOUNTSs()
        {
            try
            {
                return ACCOUNTSDAO.GetACCOUNTSs();
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }

}

Donc notre UI va réfernecer la couche BLL et va utiliser la couche Tools.
La couche BLL va référencer la couche DAL et utilise éventuellement Tools.
La DAL référence les objets métier et permet l'accès aux données.

dal bll

Write a comment

Required fields are marked with *.