Michel Perfetti
Découverte de Unity
Unity est un « application block » dédié à l’injection de dépendances fournit par Microsoft. Dans cet article nous verrons comment l’utiliser pour limiter le couplage de nos applications
Par Michel Perfetti publié le 26/07/2009 à 22:57, lu 2867 fois, 5 pages
 2 | Un programme classique
Prenons un exemple simple que nous allons modifier par la suite. Cet exemple est une application Winforms qui permet d’ajouter et de lister les clients de la base Northwind. Elle est décomposée comme suit :
  • Une couche de donnée qui permet d’ajouter des clients et de les lister. Cette couche est juste le lien entre la base de données et le reste de l’application .Net : il n’y a aucun calcul ici.
  • Une couche métier qui permet d’ajouter un client et de les lister tous: cette couche permet de calculer une clé pour le client (dans Northwind la table « Customers » a une clé particulière : une chaine de 5 caractères). Elle renvoie aussi les clients par ordre alphabétique sur le nom du client.
  • Une application Cliente qui utilise les 2 couches pour afficher la liste et ajouter un client.
Les dépendances sont les suivantes (le graphique a été généré via NDepend) :
 
/content/87a3dd53-da0d-47b5-b8fd-a5d5f353e2f3/image1.png
 
Que montre ce graphique ?
  • La couche métier « LogicLayer » est directement dépendante de la couche de donnée « DataLayer »,
  • L’application est directement dépendante des 2 couches métier et données.
C’est le cas classique lorsque pour utiliser une couche logicielle, on la référence simplement là où nous en avons besoin.
Avant de continuer, voici le code la couche métier :
La classe « Customer » :

public class Customer

{

    public string Id { get; set; }

    public string ContactName { get; set; }

    public string CompanyName { get; set; }

}

La classe « CustomerDataAccess » :

public class CustomerDataAccess

{

    public Customer Insert(string id, string contactName, string companyName)

    {

        if (String.IsNullOrEmpty(id))

        {

            throw new ArgumentNullException("id");

        }

 

        if (String.IsNullOrEmpty(contactName))

        {

            throw new ArgumentNullException("contactName");

        }

 

        if (String.IsNullOrEmpty(companyName))

        {

            throw new ArgumentNullException("companyName");

        }

 

        var cnx = new SqlConnection(Properties.Settings.Default.NW);

 

        cnx.Open();

 

        using (cnx)

        {

            var cmd = new SqlCommand();

            cmd.CommandText = "insert into Customers(CustomerID,CompanyName,ContactName) values (@Id, @Comp,@Name)";

            cmd.Connection = cnx;

            cmd.Parameters.AddWithValue("@Id", id);

            cmd.Parameters.AddWithValue("@Comp", companyName);

            cmd.Parameters.AddWithValue("@Name", contactName);

            cmd.ExecuteNonQuery();

 

            return new Customer() { Id = id, CompanyName = companyName, ContactName = contactName };

        }

    }

 

    public List<Customer> GetAllCustomer()

    {

        var cnx = new SqlConnection(Properties.Settings.Default.NW);

 

        cnx.Open();

 

        using (cnx)

        {

            var result = new List<Customer>();

 

            var cmd = new SqlCommand("select CustomerID,CompanyName,ContactName from Customers");

 

            cmd.Connection = cnx;

 

            var reader = cmd.ExecuteReader();

 

            using (reader)

            {

                while (reader.Read())

                {

                    var cust = new Customer();

                    cust.Id = reader.GetString(0);

                    cust.CompanyName = reader.GetString(1);

                    cust.ContactName = reader.GetString(2);

                    result.Add(cust);

                }

            }

            return result;

        }

    }

}

Voici la couche métier :

public class CustomerLogic

{

 

    public Customer Create(string customerName, string companyName)

    {

        var cda = new DataLayer.CustomerDataAccess();

        var id = Guid.NewGuid().ToString("N").Substring(0, 5).ToUpper();

        return cda.Insert(id, customerName, companyName);

    }

 

 

    public List<Customer> GetAllCustomers()

    {

        var cda = new DataLayer.CustomerDataAccess();

        return cda.GetAllCustomer().OrderBy(cust => cust.ContactName).ToList();

    }

}

Ce code est très simple, mais l’on voit déjà que si la couche de donnée change, il faut aussi changer la couche métier, et donc par transitivité, l’application. Dans notre cas cela n’est pas très important vu le nombre de ligne de code. Mais dans une application classique ce modèle se retrouve généralement à tous les niveaux et rend une bibliothèque intermédiaire comme la couche logique, inséparable du reste du code. En définitive, on se retrouve donc avec un programme monobloc puisqu’il n’est pas possible d’isoler une partie du reste du programme.
 
» Démarrer une discussion
 
Discussion démarée par stiiifff le 29/07/2009 à 02:33, 1 commentaire(s).