View
214
Download
0
Embed Size (px)
Citation preview
• useful groups of collaborating classes that provide a solution to commonly occuring problems.
• provide a means for capturing knowledge about problems and successful solutions.
vsPatterns• More abstract that
frameworks • description of the way a
type of problem can be solved, but not in themselves solutions, as they can’t be directly implemented.
• They are more primitive than frameworks
Frameworks
• Frameworks (e.g. .net framework, xna)
• Partially completed software systems that may be targeted at a specific type of application.
• Re-usable mini architectures.
• Can be customised by specialisation of classes, add-in operations and classes.
A Pattern Catalogue• Lists commonly used design patterns using pattern
templates
• Problem – describes the problem• Context – describes how it occurs• Forces – constraints or issues that must be addressed by
solution• Solution – describes solution approaches
• Code fragments – show how the solution can be implemented in code
E.g. see http://www.dofactory.com/Patterns/Patterns.aspx
Example• Whole-part pattern – specifically supports
aggregation and composition relationships in UML (see page 334).
• Gang of Four (GOF) developed sets of design patterns and guidelines for their use.
• (Gamma Helm Johnston and Vlissides)
Client Whole
Service_1Service_2
Part 2
Service_b1Service_b2
Part 1
Service_a1Service a_2
• Scope of a pattern: class level (static- relationships) or object level (dynamic)
• Patterns are based on principles of good design: maximise encapsulation/ using composition– Maintainability– Extensibility– Restructuring– portability
3 Types of Design Pattern (GOF)• Creational –concerned with how objects are
constructed
• Structural- address issues concerned with the way classes and objects are organised.
• Behavioural- describe how objects communicate
• See c# examples on ...http://www.dofactory.com/Patterns/Patterns.aspx
Example Creational Pattern:Singleton• Problem: Ensure a class has only one instance and provide a global
point of access to it.e.g. In water safety we only want one Water safety Authority object,
which needs global access.
Solution:• Make the constructor private• Have a get_instance method to either create the object or return
the object reference.
Class singleton
_uniqueinstance-singletondata
+get_instance+getdata-singleton
C# implementationclass Singleton { private static Singleton _instance; // Constructor is 'protected‘ not public as usual protected Singleton() { } public static Singleton Instance() { if (_instance == null) { _instance = new Singleton(); } return _instance; } }http://www.dofactory.com/Patterns/Patterns.aspxNote this is not thread safe.
Structural Pattern example: Composite
• Problem: to represent whole-part hierarchies so that both offer the same interface to client objects.
• Context : Both composite and component objects exist and should be treated in the same way.
• Solution : Combine inheritance and aggregation hierarchies. Compose objects into tree structures to represent part-whole hierarchies.
See figs 15.10, 15.14 Bennett et al
SoundClip
+play()
Advert
Advert sequence
MediaClipCollection[n]
+play()+addclip()+=removeclip()+getchild()+changesequence()
Media Clip
_uniqueinstance-singletondata
+play()
VideoClip
+play()
* ordered
For all m in MediaClipCollectionm.play()
Example Behavioural Pattern : state
Problem: operations done differently on an object dependent on its state.
Description: Allow an object to alter its behavior when its internal state changes. The object will appear to change its class.
• Create additional classes, one for each state so that each holds a state-sepcific version of the operation.
• ‘pure state’ classes contain no attributes, just redefinitions of operations.
• This should only be used for objects with significant state-dependent behaviour, as there is a big code overhead with the extra classes.
• An object has complex behaviour which is dependent on its STATE
• The original object delegates reponsibility to the appropriate state object
• A changestate() method is sent to the parent who invokes a nextstate method.
Example Behavioural Pattern 2 : Command
• An object is used to encapsulate all the information needed to call a method at a later time:- the method name, the object that owns the method and values for the method parameters.
– client instantiates the command object and provides the information required to call the method at a later time.
– invoker decides when the method should be called. – receiver is an instance of the class that contains the method's code.
• makes it easier to construct general components that need to delegate, sequence or execute method calls at a time of their choosing without the need to know the owner of the method or the method parameters.
• Good for allowing undos.
How to use design Patterns• NOT for the sake of it – there are many examples of badly
used patterns.• Analyse problem and context• Ensure that you really understand patterns• Find a pattern that addresses a similar problem, read and
study it and determine whether it gives you a better solution
• Check it there is a simpler solution• Check that the context of the pattern similar to your
problem• Make sure the consequences of using the pattern are
acceptable.• Examine sample code.• Apply and refine.
A pattern.. (hillside.net)• solves a problem: Patterns capture solutions, not
just abstract principles or strategies. • is a proven concept: Patterns capture solutions
with a track record, not theories or speculation. • describes a relationship: Patterns don't just
describe modules, but describe deeper system structures and mechanisms.
• has a significant human component (minimize human intervention). All software serves human comfort or quality of life; the best patterns explicitly appeal to aesthetics and utility.
• A pattern language defines a collection of patterns and the rules to combine them into an architectural style. Pattern languages describe software frameworks or families of related systems.
• The solution isn't obvious: Many problem-solving techniques (such as software design paradigms or methods) try to derive solutions from first principles. The best patterns generate a solution to a problem indirectly--a necessary approach for the most difficult problems of design.