Overblog Suivre ce blog
Administration Créer mon blog

Présentation

  • : Romagny13 - Du .NET,du pur .NET
  • Romagny13 - Du .NET,du pur .NET
  • : Cycle de progression Faire (quelque chose qui marche) -> comprendre ce que l’on fait/comment cela marche -> pousser plus loin les notions
  • Contact

Recherche

Articles Récents

12 avril 2014 6 12 /04 /avril /2014 18:07

 

State.png
L’interface , on pourrait aussi utiliser une classe abstraite et une énumération indiquant l’état clairement .
  public interface IState 
    {
        bool CanDoWork();
        void DoWork(Context context);
        Status Status { get; }
    } 
// cela pourrait être par exemple New,Canceled,Shipped etc. 
    public enum Status 
    {
        StateA,
        StateB
    }
Les états possibles, par exemple deux états A et B
  public class StateA : IState 
    {
        public Status Status
        {
            get { return Status.StateA ; }
        }
        public bool CanDoWork()
        {
            return false;
        }
        public void DoWork(Context context)
        {
            // Variante 
            //if (!CanDoWork()) 
            //    throw new NotImplementedException("message"); 
            // ou 
            context.Change(new StateB());
        }
    }
    public class StateB : IState 
    {
        public Status Status
        {
            get { return Status.StateB; }
        }
        public bool CanDoWork()
        {
            return true;
        }
        public void DoWork(Context context)
        {
            //... 
            context.Change(new StateA());
        }
    }
La classe avec laquelle on va réellement intéragir, cela pourrait être par exemple une classe Order avec plusieurs états tels que OrderNewState, OrderCanceledState,OrderShippedState …
public class Context 
    {
        private IState _state;
     

        public Status Status

        {

            get { return _state.Status; }

        }

        public Context(IState state)
        {
            this._state = state;
        }
        public bool CanDoWork()
        {
            return _state.CanDoWork();
        }
        public void DoWork()
        {
            _state.DoWork(this);
        }

        internal void Change(IState state)
        {
            this._state = state;
            RaiseStateChanged(_state);
        }
        public event EventHandler<StateChangedEventArgs> StateChanged;
        private void RaiseStateChanged(IState state)
        {
            EventHandler<StateChangedEventArgs> handler = StateChanged;
            if (handler != null)
                handler(this, new StateChangedEventArgs(state));
        }
    }
    public class StateChangedEventArgs 
    {
        private IState _state;
        public IState State
        {
            get { return _state; }
        }
        public StateChangedEventArgs(IState state)
        {
            this._state = state;
        }
    }
Utilisation
private void button1_Click(object sender, EventArgs e)
        {
            Context context = new Context(new StateA());
            context.StateChanged += context_StateChanged;
            context.DoWork();// l'état passe à StateB 
            context.DoWork();// l'état passe à StateA 
        }
        private void context_StateChanged(object sender, StateChangedEventArgs e)
        {
            MessageBox.Show(string.Format("l'état courant est : {0} ({1:T}) ",e.State,DateTime.Now));
        } 
Repost 0
Published by Romagny13 - dans Design patterns
commenter cet article
3 mars 2014 1 03 /03 /mars /2014 17:23

L’interface - Contient une liste de membres à implémenter.
public interface IRepository<TModelBase>
    {
        List<TModelBase> GetAll();
    }

 

Le « manager »- On passe une classe Repository implémentant l’interface  dans le constructeur
public class RepositoryManager<TModelBase>
    {
        private IRepository<TModelBase> repository;
 
        public RepositoryManager(IRepository<TModelBase> repository)
        {
            this.repository = repository;
        }
 
        public List<TModelBase> getAll()
        {
            return repository.GetAll();
        }
    }

 

2 Classes exemples implémentant l’interface
public class ArticleRepository : IRepository<ArticleModel>
    {
        public List<ArticleModel> GetAll()
        {
            return new List<ArticleModel>() { new ArticleModel() { ArticleName = "Jean 1" }, new ArticleModel() { ArticleName = "Jean 2" } };
        }
 
    }
public class OtherArticleRepository : IRepository<ArticleModel>
    {
        public List<ArticleModel> GetAll()
        {
            return new List<ArticleModel>() { new ArticleModel() { ArticleName = "Blouson 1" }, new ArticleModel() { ArticleName = "Blouson 2" } };
        }
    }
public class ArticleModel
    {
        public string ArticleName { get; set; }
    }

 

Démonstration
Dans le premier cas ce sera une liste de « jeans »
Dans le second cas ce sera une liste de « blousons »
De cette façon on peut changer très facilement la source de données .Exemple on peut implémenter un repository allant chercher les informations dans un document Xml et un autre allant les chercher dans une base de données .
  IRepository<ArticleModel> repository;
 
        private void button1_Click(object sender, EventArgs e)
        {
            repository = new ArticleRepository();
            RepositoryManager<ArticleModel> repositoryManager = new RepositoryManager<ArticleModel>(repository);
 
            dataGridView1.DataSource = repositoryManager.getAll();
        }
 
        private void button2_Click(object sender, EventArgs e)
        {
            repository = new OtherArticleRepository();
            RepositoryManager<ArticleModel> repositoryManager = new RepositoryManager<ArticleModel>(repository);
 
            dataGridView1.DataSource = repositoryManager.getAll();
        }

 

Repost 0
Published by Romagny13 - dans Design patterns
commenter cet article
3 octobre 2007 3 03 /10 /octobre /2007 00:06
Repost 0
Published by Romagny13 - dans Design patterns
commenter cet article
8 septembre 2007 6 08 /09 /septembre /2007 15:13
[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();
 
Repost 0
Published by Romagny13 - dans Design patterns
commenter cet article
8 septembre 2007 6 08 /09 /septembre /2007 10:01
[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();
        }
    }
 
Repost 0
Published by Romagny13 - dans Design patterns
commenter cet article
7 septembre 2007 5 07 /09 /septembre /2007 21:00
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
Repost 0
Published by Romagny13 - dans Design patterns
commenter cet article
13 juillet 2007 5 13 /07 /juillet /2007 09:35
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/
Repost 0
Published by Romagny13 - dans Design patterns
commenter cet article