Click here to Skip to main content
14,096,353 members
Click here to Skip to main content
Add your own
alternative version

Tagged as


227 bookmarked
Posted 5 Aug 2008
Licenced CPOL

Design pattern FAQ Part 3 ( Design pattern training series)

, 20 Oct 2011
Rate this:
Please Sign up or sign in to vote.
Design pattern FAQ Part 3 State Pattern, Stratergy pattern,Visitor pattern, Adapter and fly weight


This FAQ article is continuation to design pattern FAQ part 1 and 2. In this article we will try to understand state pattern,stratergy,visitor,adapter and flyweight pattern.

In case your are completely new to design patterns or you really do not want to read this complete   article do see our free design pattern Training and interview questions / answers videos.

If you have not read my previous section you can always read from below



Can you explain state pattern?


State pattern allows an object to change its behavior depending on the current values of the object. Consider the figure ‘State pattern example’. It’s an example of a bulb operation. If the state of the bulb is off and you press the switch the bulb will turn off. If the state of bulb is on and you press the switch the bulb will be off. So in short depending on the state the behavior changes.

Figure: - State pattern example

Now let’s try to implement the same bulb sample in C#. Figure ‘State pattern in action’ shows both the class and the client code. We have made a class called as ‘clsState’ which has an enum with two state constants ‘On’ and ‘Off’. We have defined a method ‘PressSwitch’ which toggles its state depending on the current state. In the right hand side of the same figure we have defined a client which consumes the ‘clsState’ class and calls the ‘PressSwitch()’ method. We have displayed the current status on the textbox using the ‘getStatus’ function.

When we click the press switch it toggles to the opposite state of what we have currently.

Figure: - State pattern in action

Can you explain strategy pattern?

Strategy pattern are algorithms inside a class which can be interchanged depending on the class used. This pattern is useful when you want to decide on runtime which algorithm to be used.

Let’s try to see an example of how strategy pattern works practically. Let’s take an example of a math’s calculation where we have strategies like add and substract. Figure ‘Strategy in action’ shows the same in a pictorial format. It takes two numbers and the depending on the strategy it gives out results. So if it’s an addition strategy it will add the numbers, if it’s a substraction strategy it will give the substracted results. These strategies are nothing but algorithms. Strategy pattern are nothing but encapsulation of algorithms inside classes.

Figure: - Strategy in action

So the first thing we need to look in to is how these algorithms can be encapsulated inside the classes. Below figure ‘Algorithm encapsulated’ shows how the ‘add’ is encapsulated in the ‘clsAddStatergy’ class and ‘substract’ in the ‘clsSubstractStatergy’ class. Both these classes inherit from ‘clsStratergy’ defining a ‘calculate’ method for its child classes.

Figure: - Algorithms encapsulated

Now we define a wrapper class called as ‘clsMaths’ which has a reference to the ‘clsStatergy’ class. This class has a ‘setStatergy’ method which sets the strategy to be used.

Figure: - Strategy and the wrapper class

Below figure ‘Strategy client code’ shows how the wrapper class is used and the strategy object is set on runtime using the ‘setStatergy’ method.

Figure: - Strategy client code

Can you explain visitor pattern?

Visitor pattern allows us to change the class structure with out changing the actual class. Its way of separating the logic and algorithm from the current data structure. Due to this you can add new logic to the current data structure with out altering the structure. Second you can alter the structure with out touching the logic.

Consider the below figure ‘Logic and data structure’ where we have a customer data structure. Every customer object has multiple address objects and every address object had multiple phone objects. This data structure needs to be displayed in two different formats one is simple string and second XML. So we have written two classes one is the string logic class and other is the XML logic class. These two classes traverse through the object structure and give the respective outputs. In short the visitor contains the logic.

Figure: - Logic and data structure

Let’s take the above customer sample and try to implement the same in C#. If you are from other programming you should be able to map the same accordingly. We have created two visitor classes one which will be used to parse for the string logic and other for XML. Both these classes have a visit method which takes each object and parses them accordingly. In order to maintain consistency we have implemented them from a common interface ‘IVisitor’.

Figure :- Visitor class

The above defined visitor class will be passed to the data structure class i.e. the customer class. So in the customer class we have passed the visitor class in an ‘Accept’ function. In the same function we pass this class type and call the visit function. The visit function is overloaded so it will call according to the class type passed.

Figure: - Visitor passed to data structure class

Now every customer has multiple address objects and every address has multiple phone objects. So we have ‘objAddresses’ arraylist object aggregated in the ‘clsCustomer’ class and ‘objPhones’ arraylist aggregated in the ‘clsAddress’ class. Every object has the accept method which takes the visitor class and passes himself in the visit function of the visitor class. As the visit function of the visitor class is overloaded it will call the appropriate visitor method as per polymorphism.

Figure: - Customer, Address and phones

Now that we have the logic in the visitor classes and data structure in the customer classes its
time to use the same in the client. Below figure ‘Visitor client code’ shows a sample code snippet for using the visitor pattern. So we create the visitor object and pass it to the customer data class. If we want to display the customer object structure in a string format we create the ‘clsVisitorString’ and if we want to generate in XML format we create the ‘clsXML’ object and pass the same to the customer object data structure. You can easily see how the logic is now separated from the data structure.

Figure: - Visitor client code


What the difference between visitor and strategy pattern?

Visitor and strategy look very much similar as they deal with encapsulating complex logic from data. We can say visitor is more general form of strategy.
In strategy we have one context or a single logical data on which multiple algorithms operate. In the previous questions we have explained the fundamentals of strategy and visitor. So let’s understand the same by using examples which we have understood previously. In strategy we have a single context and multiple algorithms work on it. Figure ‘Strategy’ shows how we have a one data context and multiple algorithm work on it.

Figure: - Strategy

In visitor we have multiple contexts and for every context we have an algorithm. If you remember the visitor example we had written parsing logic for every data context i.e. customer, address and phones object.

Figure: - Visitor

So in short strategy is a special kind of visitor. In strategy we have one data context and multiple algorithms while in visitor for every data context we have one algorithm associated. The basic criteria of choosing whether to implement strategy or visitor depends on the relationship between context and algorithm. If there is one context and multiple algorithms then we go for strategy. If we have multiple contexts and multiple algorithms then we implement visitor algorithm.

Can you explain adapter pattern?

Many times two classes are incompatible because of incompatible interfaces. Adapter helps us to wrap a class around the existing class and make the classes compatible with each other. Consider the below figure ‘Incompatible interfaces’ both of them are collections to hold string values. Both of them have a method which helps us to add string in to the collection. One of the methods is named as ‘Add’ and the other as ‘Push’. One of them uses the collection object and the other the stack. We want to make the stack object compatible with the collection object.

Figure: - Incompatible interfaces

There are two way of implementing adapter pattern one is by using aggregation (this is termed as the object adapter pattern) and the other inheritance (this is termed as the class adapter pattern). First let’s try to cover object adapter pattern.

Figure ‘Object Adapter pattern’ shows a broader view of how we can achieve the same. We have a introduced a new wrapper class ‘clsCollectionAdapter’ which wraps on the top of the ‘clsStack’ class and aggregates the ‘push’ method inside a new ‘Add’ method, thus making both the classes compatible.

Figure: - Object Adapter pattern

The other way to implement the adapter pattern is by using inheritance also termed as class adapter pattern. Figure ‘Class adapter pattern’ shows how we have inherited the ‘clsStack’ class in the ‘clsCollectionAdapter’ and made it compatible with the ‘clsCollection’ class.

Figure :- Class adapter pattern

What is fly weight pattern?

Fly weight pattern is useful where we need to create many objects and all these objects share some kind of common data. Consider figure ‘Objects and common data’. We need to print visiting card for all employees in the organization. So we have two parts of data one is the variable data i.e. the employee name and the other is static data i.e. address. We can minimize memory by just keeping one copy of the static data and referencing the same data in all objects of variable data. So we create different copies of variable data, but reference the same copy of static data. With this we can optimally use the memory.

Figure: - Objects and common data

Below is a sample C# code demonstration of how flyweight can be implemented practically. We have two classes, ‘clsVariableAddress’ which has the variable data and second ‘clsAddress’ which has the static data. To ensure that we have only one instance of ‘clsAddress’ we have made a wrapper class ‘clsStatic’ and created a static instance of the ‘clsAddress’ class. This object is aggregated in the ‘clsVariableAddress’ class.

Figure: - Class view of flyweight

Figure ‘Fly weight client code’ shows we have created two objects of ‘clsVariableAddress’ class, but internally the static data i.e. the address is referred to only one instance.

Figure: - Fly weight client code

Below is a nice Design Pattern youtube video which explains step by step how to use Design pattern in C# projects.

In case your are completely new to design patterns or you really do not want to read this complete article do see our free design pattern Training and interview questions / answers videos.

Check out factory design pattern video click here 

Design Pattern with a Project

The best way to learn Design patterns is by doing a project. So this tutorial teaches you pattern by pattern but if you want to learn Design pattern using a project approach then, click on this link for the same.


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

You may also be interested in...

Comments and Discussions

BugThe State pattern implementation/example is incorrect. Pin
tushargw25-Oct-18 3:24
membertushargw25-Oct-18 3:24 
GeneralMy vote of 5 Pin
Humayun Kabir Mamun25-Aug-14 23:47
memberHumayun Kabir Mamun25-Aug-14 23:47 
GeneralVery useful. Thanks. Pin
jahfer17-Aug-13 7:42
memberjahfer17-Aug-13 7:42 
GeneralPerfect !!! Pin
raananv20-Nov-11 10:43
memberraananv20-Nov-11 10:43 
Question2008 article being bumped up constantly Pin
HaBiX20-Oct-11 22:00
memberHaBiX20-Oct-11 22:00 
AnswerRe: 2008 article being bumped up constantly Pin
Shivprasad koirala20-Oct-11 22:27
memberShivprasad koirala20-Oct-11 22:27 
GeneralMy vote of 5 Pin
abdoo323218-Oct-11 22:28
memberabdoo323218-Oct-11 22:28 
GeneralMy vote of 5 Pin
Monjurul Habib14-Oct-11 9:44
professionalMonjurul Habib14-Oct-11 9:44 
GeneralMy vote of 5 Pin
lovejun22-Nov-10 4:01
memberlovejun22-Nov-10 4:01 
Generalanother good article Pin
Donsw29-Jan-09 7:31
memberDonsw29-Jan-09 7:31 
GeneralRe: another good article Pin
Shivprasad koirala30-Jan-09 8:04
memberShivprasad koirala30-Jan-09 8:04 
Questionthanks for ur effort , but ... ? Pin
Ahmed R El Bohoty26-Nov-08 11:02
memberAhmed R El Bohoty26-Nov-08 11:02 
QuestionUpdate??? Pin
Giovanni Bejarasco25-Oct-08 16:27
memberGiovanni Bejarasco25-Oct-08 16:27 
General72 books marks ,34 + votes Great Pin
sid889787025-Oct-08 8:59
membersid889787025-Oct-08 8:59 
GeneralMisleading examples Pin
Giovanni Bejarasco14-Oct-08 19:10
memberGiovanni Bejarasco14-Oct-08 19:10 
GeneralThank you !! Pin
Abhijit Jana6-Sep-08 2:45
mentorAbhijit Jana6-Sep-08 2:45 
GeneralStrategy. Not Stratergy Pin
hacey24-Aug-08 3:13
memberhacey24-Aug-08 3:13 
GeneralState Pattern Pin
Sceptical21-Aug-08 10:02
memberSceptical21-Aug-08 10:02 
QuestionFlyweight? Pin
supercat96-Aug-08 13:15
membersupercat96-Aug-08 13:15 
GeneralLooks good (=excellent) Pin
Tachyonx6-Aug-08 3:11
memberTachyonx6-Aug-08 3:11 
General[Message Removed] Pin
ped2ped5-Aug-08 23:19
memberped2ped5-Aug-08 23:19 
GeneralGreat explanations Pin
Danoo5-Aug-08 19:17
memberDanoo5-Aug-08 19:17 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Permalink | Advertise | Privacy | Cookies | Terms of Use | Mobile
Web03 | 2.8.190518.1 | Last Updated 21 Oct 2011
Article Copyright 2008 by Shivprasad koirala
Everything else Copyright © CodeProject, 1999-2019
Layout: fixed | fluid