Design Pattern lecture 4

Design PatternBy Julie Iskander

MSc. Communication and Electronics

Outlines Lecture 4

• Behavioral Design Patterns• Chain of Responsibility• Command• Mediator• Memento• Observer• State• Strategy• Template Method• Interpreter• Visitor• Iterator (Reading Assignment)

Behavioral Patterns

Chain of responsibility DP

• What• A replication of the business or functional process of

delegating responsibility within a hierarchy.

• Where • A requirement to manage tasks by coordinating objects and

have them cooperate within a hierarchical structure.

• Why• Avoid coupling sender of request to receiver

• How• An abstract class that represents a participant or link is

sub-classed into a set of links, and then the sub-classed links implement the functionality that represents their responsibility and can trigger the passing on of a requirement. The client determines the hierarchy among the links and initiates passing the requirement to the chain.

Chain of responsibility dp

Chain of responsibility dp

Chain of responsibility dp

Chain of responsibility

Chain of responsibility

Command DP(object - Behavioral DP)

Command DP(object - Behavioral DP)

•What• Encapsulate a request as an object, and

support undoable operations.

•Where • To issue requests to objects without knowing

anything about the operation being requested or the receiver of the request.

•Why• specify, queue, and execute requests at

different times. support undo. support logging changes

Command DP(object - Behavioral DP)

Command DP(object - Behavioral DP)

Command DP(object - Behavioral DP)

Command DP(object - Behavioral DP)

• Supporting undo and redo:• Must provide a reverse method

(Unexecute/Undo).• Might need to store additional state like the

Receiver object, the arguments to the operation performed on the receiver, and any original values in the receiver that can change as a result of handling the request.

• For one level of undo, store only the last executed command.

• For multi-level undo, store a history list of executed commands.

Command DP(object - Behavioral DP)

Mediator DP (object - Behavioral DP)

• What• Define an object that encapsulates how a set of objects

interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.

• Where • when many objects interconnect, to lessen the coupling

• Why• To lessen the coupling between objects

• How• Encapsulating collective behavior in a separate mediator

object. A mediator is responsible for controlling and coordinating the interactions of a group of objects. The objects only know the mediator, thereby reducing the number of interconnections.

Mediator DP (object - Behavioral DP)

Mediator DP (object - Behavioral DP)

Mediator DP (object - Behavioral DP)

Mediator DP (object - Behavioral DP)

Mediator DP (object - Behavioral DP)

Mediator DP (object - Behavioral DP)

•Façade make requests to the subsystem, while mediator enables cooperative behaviour between colleagues objects

Mediator DP (object - Behavioral DP)

• What• capture and externalize an object's internal state

so that the object can be restored to this state later.

• Where • To store a snapshot of internal state of an object,

to implement checkpoints

•Why• To implement checkpoints, save state, undo

mechanisms

• How• use passive class to get and set state of Originator

class

MeMento DP (object - Behavioral DP)

MeMento DP (object - Behavioral DP)

MeMento DP (object - Behavioral DP)

•Memento objects are passive

•Memento can be used to maintain state for undoable operations for Command DP

•Used in Games to store check points

MeMento DP (object - Behavioral DP)

Observer DP (object - Behavioral DP)

• What• An Observer pattern is a design based on a one-to-many

relationship, where one is a publisher that publishes an event against which many subscribers register an interest.

• Where • A requirement to initiate and manage communications among a

society of objects.

• Why• To programmatically establish and manage a set of relationships

among objects at run time.

• How• Create a subject object (publisher) and any number of observer

objects (subscribers), and then wire an event handler in the observer objects to an event in the subject object. In .NET, we use a delegate event-handling model to wire the observer objects to the publisher's event—delegates simplify the architecture articulated by GoF.

Observer DP (object - Behavioral DP)

Observer DP (object - Behavioral DP)

Observer DP (object - Behavioral DP)

Observer DP (object - Behavioral DP)

State DP (object - Behavioral DP)

• What• Allow an object to alter its behavior when its internal

state changes. The object will appear to change its class.

• Where • An object's behavior depends on its state, and it must

change its behavior at run-time depending on that state.

•Why• This lets you treat the object's state as an object in

its own right that can vary independently from other objects.

• How• Define state as an object on its own

State DP (object - Behavioral DP)

State DP (object - Behavioral DP)

Strategy DP(object-behavioural DP)

• What• A design that presents a family of algorithms or business rules

encapsulated in classes that can be swapped.

• Where • A requirement for the contextual implementation of different

algorithms or business rules without the use of conditional code.

• Why• A design that separates the choice of algorithm or business

rule from its implementation and delegates the contextual choice of algorithm or business rule to client code.

• How• Design an abstract strategy class that includes an abstract

method from which an algorithm may be called. Prepare a context class to contain an abstract strategy class and then code the client to choose the strategy and inform the context class of the choice of strategy.

Strategy DP(object-behavioural DP)

Template Method DP(Class - Behavioral DP)

• What• Need subclasses to house different implementations

of an algorithm and defer part of the implementation to the subclass.

• Where• A requirement for a common structure to house an

algorithm, while vary the implementation of the algorithm.

• Why• A default implementation that has the flexibility for

a subclass to vary the underlying algorithm within the implementation.

• How• An abstract class exposes a Template Method that

wraps a set of functionality or methods, part of which is overridden by a subclass.

Template Method DP(Class - Behavioral DP)

Template Method DP(Class - Behavioral DP)

• Factory Methods are often called by template methods. (DoCreateDocument called by OpenDocument).

• Template methods use inheritance to vary part of an algorithm. Strategies use delegation to vary the entire algorithm.

Template Method DP(Class - Behavioral DP)

Report #3:

Interpreter DPVisitor DP

N.B. Hand Written

References

[1] Design Patterns, Christopher G. Lasater, Wordware Publishing, Inc.

[2] http://www.CodeProject.com, How I explained OOD to my wife, Al-Farooque Shubho

[3]http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod,PrinciplesOfOod

[4]http://www.CodeProject.comHow I explained Design Patterns to my wife: Part 1,By Al-FarooqueShubho

[5] http://www.shubho.net/2010/09/interface-vs-abstract-class-classic.html, Al-FarooqueShubho

[6]C# 3.0 Design Patterns, Judith Bishop

[7]Head First Design Pattern, Eric Freeman, Elisabeth Freeman, Kathy Sierra, Bert Bates

[8] Pro .NET 2.0 Code and Design Standards in C#, Mark Horner

The End

Thank you

and

Good Luck