Showing posts with label .NET Design Patterns. Show all posts
Showing posts with label .NET Design Patterns. Show all posts

Wednesday, May 8, 2013

Published 9:50 PM by with 0 comment

Template Method Pattern



Template Method Pattern

[Download cs c#]
Definition
Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template Method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure.

abstract class AbstractClass
    {
        public abstract void PrimitiveOperation1();
        public abstract void PrimitiveOperation2();

        public void TemplateMethod()
        {
            PrimitiveOperation1();
            PrimitiveOperation2();
            Console.WriteLine("Call Template Method");
        }
    }

    //Concrete Class A
    class ConcreteClassA : AbstractClass
    {
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("concreate A primi 1");
        }

        public override void PrimitiveOperation2()
        {
            Console.WriteLine("concreate A primi 2");
        }
    }

    //Concrete Class B
    class ConcreteClassB : AbstractClass
    {
        public override void PrimitiveOperation1()
        {
            Console.WriteLine("concreate B primi 1");
        }

        public override void PrimitiveOperation2()
        {
            Console.WriteLine("concreate B primi 2");
        }
    }

//calling…
            //Template Method
            AbstractClass a = new ConcreteClassA();
            a.TemplateMethod();

            AbstractClass b = new ConcreteClassB();
            b.TemplateMethod();

Read More

, ,

    email this       edit
Published 1:44 AM by with 0 comment

Composite Pattern - [Structural Patterns]


Definition
[Download cs c#]
Compose objects into tree structures to represent part-whole hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly.

    //Component class
    abstract class Component
    {
        protected string name;

        public Component(string name)
        {
            this.name = name;
        }

        public abstract void Add(Component c);
        public abstract void Remove(Component c);
        public abstract void Display(int Dept);
    }

    //Composite Class
    class Composite : Component
    {
        private List<Component> _com = new List<Component>();

        public Composite(string name):base(name)
        {

        }
        public override void Add(Component c)
        {
            _com.Add(c);
        }
        public override void Remove(Component c)
        {
            _com.Remove(c);
        }
        public override void Display(int Dept)
        {
            Console.WriteLine(new String('-',Dept)+name);

            foreach (Component component in _com)
            {
                component.Display(Dept + 2);
            }
        }
    }

        //Leaf Class
        class Leaf : Component
        {
            public Leaf(string name):base(name)
            {

            }
            public override void Add(Component c)
            {
                Console.WriteLine("Can not add to a leaf");
            }
            public override void Remove(Component c)
            {
                Console.WriteLine("Can not remove from a leaf");
            }
            public override void Display(int Dept)
            {
                Console.WriteLine(new String('-', Dept) + name);
            }
        }


            //---Composite Calling...
            Composite root = new Composite("root");
            root.Add(new Leaf("Leaf A"));
            root.Add(new Leaf("Leaf B"));

            Composite comp = new Composite("Composite X");
            comp.Add(new Leaf("Leaf XA"));
            comp.Add(new Leaf("Leaf XAB"));

            root.Add(comp);
            root.Add(new Leaf("Leaf C"));

            // Add and remove a leaf
            Leaf leaf = new Leaf("Leaf D");
            root.Add(leaf);
            root.Remove(leaf);

            // Recursively display tree
            root.Display(1);



Read More

, ,

    email this       edit

Sunday, May 5, 2013

Published 11:24 PM by with 0 comment

Observer Pattern - [Behavioral Patterns]


Observer Pattern 

[Download cs c#]

Definition

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.



    //Observer Class
    abstract class Observer
    {
        public abstract void Update();
    }


    //Subject Class
    abstract class Subject
    {
        private List<Observer> _observer = new List<Observer>();

        public void Register(Observer obs)
        {
            _observer.Add(obs);
        }

        public void Unregister(Observer obs)
        {
            _observer.Remove(obs);
        }

        public void Notify()
        {
            foreach (Observer obs in _observer)
            {
                obs.Update();
            }
        }
    }

    //StockMarket Class
    class StockMarket : Subject
    {
        private string _subjectState;

        public string SubjectState
 {
get
{
 return _subjectState;
}
set
{
 _subjectState = value;
}
}
    }


    //GoogleStockGadet Class
    class GoogleStockGadet  : Observer
    {
        private string _name;
        private string _observerState;
        private StockMarket _concreteSubject;

        public GoogleStockGadet(StockMarket conSubject, string name)
        {
            _concreteSubject = conSubject;
            _name = name;
        }

        public override void Update()
        {
            _observerState = _concreteSubject.SubjectState;
            Console.WriteLine("Observer {0}'s new state is {1}", _name, _observerState);
        }

        public StockMarket Subject
 {
 get
 {
return _concreteSubject;
 }
 set
 {
 _concreteSubject = value;
 }
 }
    }

    //MSNStockGadget Class
    class MSNStockGadget  : Observer
    {
        private string _name;
        private string _observerState;
        private StockMarket _concreteSubject;

        public MSNStockGadget(StockMarket conSubject, string name)
        {
            _concreteSubject = conSubject;
            _name = name;
        }

        public override void Update()
        {
            _observerState = _concreteSubject.SubjectState;
            Console.WriteLine("Observer {0}'s new state is {1}", _name, _observerState);
        }

        public StockMarket Subject
 {
get
{
return _concreteSubject;
}
Set
{
_concreteSubject = value;
}
 }
    }


    //YahooStockGadget Class
    class YahooStockGadget  : Observer
    {
        private string _name;
        private string _observerState;
        private StockMarket _concreteSubject;

        public YahooStockGadget(StockMarket conSubject, string name)
        {
            _concreteSubject = conSubject;
            _name = name;
        }

        public override void Update()
        {
            _observerState = _concreteSubject.SubjectState;
            Console.WriteLine("Observer {0}'s new state is {1}", _name, _observerState);
        }

        public StockMarket Subject
 {
 get
 {
 return _concreteSubject;
 }
 Set
 {
_concreteSubject = value;
 }
 }
    }

            //Calling...
            StockMarket s = new StockMarket();

            s.Register(new GoogleStockGadet(s, "X"));
            s.Register(new MSNStockGadget(s, "Y"));
            s.Register(new YahooStockGadget(s, "Y"));

            s.SubjectState = "ABC";
            s.Notify();


Read More

,

    email this       edit
Subscribe to: Posts (Atom)