Calendrier

Décembre 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 31      
<< < > >>

 

Présentation

 

Catégories

 

Articles récents

liste complète

 

Recherche

 

Liens

 

W3C

  • Flux RSS des articles

 

Design patterns

Command Pattern

Reversible Command Pattern

sources disponibles
http://blogs.msdn.com/pedram/archive/2007/10/02/reversible-command-pattern.aspx
Par Romagny13
Ecrire un commentaire - Voir les commentaires - Recommander

[Design patterns] Strategy

[Design patterns] Strategy

L’intérêt de ce design pattern est de permettre pour un même problème d’avoir plusieurs solutions
Exemple : l’exemple donné par le site dofactory est excellent, chaque classe concrète pourrait par exemple trier une collection reçue selon un algorithme ou des critères différents,cela permet à partir d’un problème commun d’avoir x implémentations
strategy.JPG
1 - Classe abstraite ou interface
public abstract class Strategy
 {
      //autres membres
    public abstract void Method1();
 }
 
2 - Implémentation (n classes)
Chaque classe implémente la(ou les méthodes abstraites) de la classe de base
public class ConcreteStrategyA : Strategy
 {
    public override void Method1()
    {
    }
 }
 
3 - Context
public class Context
 {
    Strategy strategy;
 
    public Context(Strategy strategy)
    {
      this.strategy = strategy;
    }
 
    public void CallMethod1()
    {
      strategy.Method1();
    }
 }
 
Utilisation
      // en définissant directement la strategie utilisée
        Strategy strategy = new ConcreteStrategyA();
        Strategy strategy = new ConcreteStrategyB();
        // ou en passant par le context
      Context context = new Context(new ConcreteStrategyA());
      context.CallMethod1();
 
      Context context = new Context(new ConcreteStrategyB());
      context.CallMethod1();
 
Par Romagny13
Ecrire un commentaire - Voir les commentaires - Recommander

[Design Patterns] Abstract Factory

[Design Patterns] Abstract Factory
  ClassDiagram1-copie-1.png
Exemple
public abstract class AbstractClassFactory
    {
        public abstract BaseObject CreateObject();
    }
    // IMPLEMENTATION
    public class ConcreteClassAFactory : AbstractClassFactory
    {
        public override BaseObject CreateObject()
        {
            return new ObjectA();
        }
    }
    public class ConcreteClassBFactory : AbstractClassFactory
    {
        public override BaseObject CreateObject()
        {
            return new ObjectB();
        }
    }
    //
    public abstract class BaseObject
    {
    }
    public class ObjectA : BaseObject
    {
    }
    public class ObjectB : BaseObject
    {
    }
  
 
    // FABRIQUE
    public static class ClassFactories
    {
        public static AbstractClassFactory GetAbstractClassFactory(string paramaterName)
        {
            if (paramaterName == "A")
                return new ConcreteClassAFactory();
            else
                return new ConcreteClassBFactory();
        }
    }
    // utilisation
    public class Client
    {
        private AbstractClassFactory factory;
 
        // Constructor
        public Client(AbstractClassFactory factory)
        {
            this.factory = factory;
        }
 
        public BaseObject CreateObject()
        {
          BaseObject _object = factory.CreateObject();
          return _object;
        }
    }
 
Par Romagny13
Ecrire un commentaire - Voir les commentaires - Recommander

[Design Patterns] Singleton – toutes ses déclinaisons

[Design Patterns] Singleton – toutes ses déclinaisons
1 – Singleton de base
A - Lazy initialization
    public class Singleton
    {
        private static Singleton uniqueInstance;
        //autres variables
 
        private Singleton()
        { }
 
        public static Singleton GetInstance()
        {
            if (uniqueInstance == null)
                uniqueInstance = new Singleton();
 
            return uniqueInstance;
        }
 
        //autres méthodes
    }

B - Full initialization
    public class Singleton
    {
        private static readonly Singleton uniqueInstance = new Singleton();
        //autres variables
 
        private Singleton()
        { }
 
        public static Singleton GetInstance()
        {
            return uniqueInstance;
        }
 
        //autres méthodes
    }
 
2 – Sous singleton  
 Il est possible de créer un sous singleton héritant du singleton de base 
Note : dans ce cas le constructeur de la classe de base(c'est à dire de Singleton) doit avoir une portée Protected
    public class SousSingleton : Singleton
    {
        //autres variables
 
        private SousSingleton()
            : base()
        {
        }
 
        //autres méthodes
    }
 
3 – Singleton threadSafe
pour éviter que plusieurs threads utilisent le même singleton en même temps, on « lock » celui-ci le temps qu’il est utilisé
public class Singleton
    {
        private static Singleton uniqueInstance = null;
        private static readonly object uniqueInstanceLocker = new object();
 
 
        // constructeur Private
        private Singleton()
        { }
 
        // méthode permettant de récupérer l'uniqueinstance est static
        public static Singleton GetInstance()
        {
            lock (uniqueInstanceLocker)
            {
                if (uniqueInstance == null)
                    uniqueInstance = new Singleton();
 
                return uniqueInstance;
            }
 
        }
    }
 
Utilisations
class Program
    {
        static void Main(string[] args)
        {
            Singleton singleton = Singleton.GetInstance();
            Singleton sousSingleton = SousSingleton.GetInstance();
        }
    }
 
Par Romagny13
Ecrire un commentaire - Voir les commentaires - Recommander

Design Patterns : Method Factory

Design Patterns : Method Factory
I – Présentation
Abstraction
Interface de classe ou classe abstraite
    // ne contient que des méthodes à implémenter
    public interface IAbstractInterfaceFactory
    { }
    // ou
    // contient des membres et des méthodes abstraites à implémenter
    public abstract class AbstractClassFactory
    { }
 
Implémentation
Classes héritant de l’interface ou de la classe abstraite
    public class ConcreteClass1Factory : AbstractClassFactory // ou IAbstractInterfaceFactory
    { }
    public class ConcreteClass2Factory : AbstractClassFactory // ou IAbstractInterfaceFactory
    { }
    public class ConcreteClass3Factory : AbstractClassFactory // ou IAbstractInterfaceFactory
    { }
    // ...
 
Fabrique
Classe contenant une fonction attendant un paramètre
Cette méthode détermine à partir du paramètre l’instance de la classe « concrète » à créer et à retourner
    public static class ClassFactories
    {
        public static AbstractClassFactory GetAbstractClassFactory(string parameter)
        {
            // retourne selon le parametre une nouvelle instance de ConcreteClass1Factory ou ConcreteClass2Factory ou ConcreteClass3Factory
        }
    }
 
Ensuite :
            AbstractClassFactory abstractClassFactory = ClassFactories.GetAbstractClassFactory("mon parametre");
            // ou
            IAbstractInterfaceFactory iAbstractInterfaceFactory = ClassFactories.GetAbstractClassFactory("mon parametre");
 
 
II - Exemple avec DbProviderFactory du Framework .NET
 
  ClassDiagram1-copie-4.jpg
Ici :
Abstraction : classe abstraite DbProviderFactory
Implémentation :
-          SqlClientFactory
-          OleDbFactory
-          OdbcFactory
Fabrique :
-          DbProviderFactories 
Déroulement :
on appelle la méthode GetFactory() de la fabrique DbProviderFactories
en passant un paramètre (le ProviderName ,ex : « System.Data.SqlClient »),
c’est grâce à ce paramètre que la classe concrète (SqlClientFactory,OleDbFactory,OdbcFactory) est déterminée
et qu’une instance de celle-ci(la classe concrète)  est retournée
ensuite lorsque l’on fera appel aux méthodes CreateCommand(),… ce sera la méthode dans la classe concrète correspondante qui sera appelée
 
ex :
DbProviderFactory dbProviderFactory = DbProviderFactories.GetFactory("System.Data.SqlClient");
DbConnection dbConnection = dbProviderFactory.CreateConnection(); // c'est la méthode CreateConnection de SqlClientFactory qui est appelée
Par Romagny13
Ecrire un commentaire - Voir les commentaires - Recommander

Design patterns

Design patterns

http://www.dofactory.com/Patterns/Patterns.aspx

Par Romagny13
Ecrire un commentaire - Voir les commentaires - Recommander

Design patterns – 1 Singleton

Design patterns – 1 Singleton

Singleton.JPG

Full initialization
public class Singleton
    {
        private static readonly Singleton _instance = new Singleton();
 
        private Singleton()
        { }
 
        public static Singleton GetInstance()
        {
            return _instance;
        }
    }
 
Lazy initialization
public class Singleton
    {
        private static Singleton _instance; 
  
        private Singleton()
        { } 
        public static Singleton GetInstance()
        {
            if (_instance  == null)
                _instance  = new Singleton();
            return _instance ;
        }
      }
 
Exemple :
Form1
private void button1_Click(object sender, EventArgs e)
        {
            Singleton.GetInstance().Message = "mon message";
            MessageBox.Show(Singleton.GetInstance().Message);
            Form2 oForm2 = new Form2();
            oForm2.ShowDialog();
        }
 
Form2
 private void button1_Click(object sender, EventArgs e)
        {
            MessageBox.Show(Singleton.GetInstance().Message);
        }
 
Singleton utilisé
public class Singleton
    {
        private static readonly Singleton _instance = new Singleton();
 
        public string Message;
 
        private Singleton()
        { }
 
        public static Singleton GetInstance()
        {
            return _instance;
        }
    }
 

http://webman.developpez.com/articles/dotnet/patterns/singleton/
Par Romagny13
Ecrire un commentaire - Voir les commentaires - Recommander
Créer un blog sur over-blog.com - Contact - C.G.U. - Rémunération en droits d'auteur - Signaler un abus