Archives de la catégorie Design Patterns

Les patterns de construction dans le framework.Net

Les patterns de construction ont pour rôle de masquer la complexité de création des objets et de rendre le système indépendant du processus d’instanciation des classes. Pour ce faire ces patterns privilégient l’utilisation des Interfaces ou des classes abstraites dans la relation entre les objets en masquant les classes concrètes au client final.

Le choix entre Classe Abstraite et Interface ?

– Choisir une classe abstraite si la classe doit contenir des comportements par défauts, comme par exemple une méthode codée dans la classe abstraite qui pourra être utilisée par l’ensemble des classes concrètes.

– Choisir une interface si toutes les classes concrètes ont leurs propres implémentations.

  • Définition des Patterns de créations :

  1. Abstract Factory : Ce modèle fournit une interface pour créer des familles d’objets liés ou dépendants sans spécifier leurs classes concertes. Créer des objets, de classes abstraites différentes, mais de mêmes familles de classes concrètes. L’abstract factory ne fait rien d’autre que de créer des objets à la différence du pattern Factory Method. Dans ce pattern il faut utiliser un singleton pour n’avoir q’une seule instance de chacune des fabriques concrètes.
  2. Factory Method : Permets de déléguer aux sous-classes l’instanciation au travers d’une méthode abstraite de création des objets. L’appel du constructeur des sous-classe peut être fait en passant un paramètre a la Factory Method. La différence avec Abstract Factory, est que la classe possède d’autres responsabilités que le simple fait de créer des objets.
  3. Singleton : Ce modèle garantit qu’une classe n’a qu’une seule instance et fournit un point d’accès à celle çi.
  4. Builder : Permet d’abstraire la construction d’objets complexe : objets composés – par exemple la fenêtre d’une application composée de différents menus, d’un titre, etc. Sans se soucier par exemple du style de rendu (menu classique, Ruban office …)
  5. Prototype : Il est utilisé pour créer un objet en double ou clone de l’objet courant.
  • Patterns de créations dans le framework.Net :

Voici un exemple de code C# utilisant les 5 types de pattern de conception présent dans le framework.net :

public int DbProviderFactoryPatterns()
{
    // 1 - Abstract Factory : Classes concrètes SQL.. / ODBC.. / OLEDB..
    // Familles de produits : Connection / Command, etc. Commence par CreateXXX
    var dbProviderFactory = DbProviderFactories.GetFactory("System.Data.SqlClient");// 2 - Factory Method

    var dbConnection = dbProviderFactory.CreateConnection();                        // 3 - Factory Method

    var singletonSqlClientFactory = SqlClientFactory.Instance;                      //  4 - Singleton

    if (singletonSqlClientFactory.Equals(dbProviderFactory))
    {
        Console.WriteLine("Provider SQL");
    }

    var connectionStringBuilder = dbProviderFactory.CreateConnectionStringBuilder();//  5 - Builder
    connectionStringBuilder.ConnectionString =                                      //  5 - Builder
        "Data Source=ServerName;Initial Catalog=DatabaseName;Persist Security " +
        "Info=True;Connection Timeout =60;Integrated Security=SSPI";

    dbConnection.ConnectionString = connectionStringBuilder.ConnectionString;

    var dbCommand = dbProviderFactory.CreateCommand();                       // 6 - Factory Method
    dbCommand.CommandType = CommandType.Text;
    dbCommand.CommandText = "select count(*) from Table1";
    dbCommand.Connection = dbConnection;

    if (dbCommand is ICloneable)
    {
        var prototypeDbCommand = (ICloneable)dbCommand;                       // 7 - Prototype
        var dbCommand2 = (DbCommand)prototypeDbCommand.Clone();               // 7 - Prototype
        dbCommand2.CommandText = "select count(*) from Table2";
    }

    try
    {
        dbConnection.Open();
        return dbCommand.ExecuteNonQuery();
    }
    finally
    {
        if (dbConnection.State != System.Data.ConnectionState.Closed)
            dbConnection.Close();
    }
    return -1;        
}

Diagramme UML des classes :

image

  • Abstract Factory : System.Data.Common.DbProviderFactory
Abstraction Fabrique concrète Classe abstraite à créer(famille de produits) Classe concrète à créer(famille de produits) Commentaires
DbProviderFactory SqlClientFactoryOdbcFactory DbCommandDbConnection OdbcCommand
SqlCommand
OdbcConnection
SqlConnection
Le pattern utilise un singleton pour ne disposer que d’une seule instance des fabriques concrètes pour l’ensemble des clients l’utilisant.Les méthodes CreateXXX sont des Factory Method chargées de créer chacune des familles de produits
  • Factory Method  : System.Data.Common.DbProviderFactories

Dans ce cas la factory method ne respecte pas le pattern avec son abstraction comme nous pourrons le voir dans la classe System.Net.WebRequest, mais grâce au paramètre passé à cette méthode (par réflexion) elle renverra l’instance du singleton d’une des fabriques concrète : SqlClientFactory ou OdbcFactory

  • Singleton  : System.Data.SqlClient.SqlClientFactory.Instance

Les instances uniques de chacune des factory sont créées ici par le constructeur statique de la classe en temps qu’instance de classe : OdbcFactory.Instance et SqlClientFactory.Instance

  • Builder  : System.Data.Common.DBConnectionStringBuilder
Abstraction Monteur concret Classe à monter
DBConnectionStringBuilder SqlConnectionStringBuilder
OdbcConnectionStringBuilder
StringString
  • Prototype  : System.ICloneable
Abstraction Classe à instance unique
ICloneable SqlCommand
OdbcCommand
SqlConnection
OdbcConnction
  • Autre exemples :

Voici d’autres exemples de ces patterns de création dans le framework :

public void WebRequestPatterns()
{
    var uriBuilder = new UriBuilder();                //  8 - Builder
    uriBuilder.Scheme = "http";
    uriBuilder.Host = "www.google.fr";

    var webRequest = WebRequest.Create(uriBuilder.Uri);  // 9 - Factory Method

    var webResponse = webRequest.GetResponse();          // 10 - Factory Method
}
public void XmlPatterns()
{
    var xmlDocument = new XmlDocument();
    xmlDocument.Load("file.xml");
    var xmlNode = xmlDocument.CloneNode(true);          // 11 - Prototype
}

Diagramme UML du pattern Factory Method de WebRequest

image

Publicités

, , , , , , ,

Poster un commentaire

%d blogueurs aiment cette page :