What is Design Patterns?

Transcription

1 Paweł Zajączkowski

2 What is Design Patterns? 1. Design patterns may be said as a set of probable solutions for a particular problem which is tested to work best in certain situations. 2. In other words, Design patterns, say you have found a problem. Certainly, with the evolution of software industry, most of the others might have faced the same problem once. 3. Design pattern shows you the best possible way to solve the recurring problem.

3 Uses of Design Patterns 1. While creating an application, we think a lot on how the software will behave in the long run. It is very hard to predict how the architecture will work for the application when the actual application is built completely. 2. There might issues which you cant predict and may come while implementing the software. 3. Design patterns helps you to find tested proven design paradigm. 4. Following design pattern will prevent major issues to come in future and also helps the other architects to easily understand your code.

4 Uses of Design Patterns 1. Design Patterns provide standardized and efficient solutions to software design and programming problems that are reusable in your code. Software Architects and developers use them to build high quality robust applications. 2. You may also create your own custom Design Patterns. Whenever you come up with a certain solution that is reusable in a vast majority of your projects, you may decide to abstract a design pattern out of it. Then you may create your own library of patterns and share them within your whole company, thus creating standards and ameliorating maintainability.

5 History of Design Patterns 1. When the word design pattern comes into mind, the first thing that one may think is the classical book on Design Pattern "Gangs of Four" which was published by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides. 2. In this book, it is first discussed capabilities and pitfalls of Object oriented programming, and later on it discusses about the classic Design Patterns on OOP.

6 Patterns are not: 1. Patterns are not idioms! 2. Patterns are not algorithms! 3. Patterns are not components! 4. Patterns are not a silver bullet

7 Types of Design Pattern Design patterns can be divided into 3 categories. 1. Creational Patterns : These patterns deals mainly with creation of objects and classes. 2. Structural Patterns : These patterns deals with Class and Object Composition. 3. Behavioural Patterns : These mainly deals with Class - Object communication. That means they are concerned with the communication between class and objects.

8 Creational Patterns 1. Abstract Factory Pattern: Create instances of classes belonging to different families 2. Builder Pattern: Separate representation and object construction 3. Factory Method Pattern: Create instances of derived classes 4. Prototype Pattern: Clone or copy initialized instances 5. Singleton Pattern: Class with only one single possible instance

9 Structural Patterns 1. Adapter Pattern: Match interfaces of classes with different interfaces 2. Bridge Pattern: Separate implementation and object interfaces 3. Composite: Simple and composite objects tree 4. Decorator: Dynamically add responsibilities to objects 5. Facade: Class that represents subclasses and subsystems 6. Flyweight: Minimize memory usage by sharing as much data as possible with similar objects 7. Proxy: Object that represents another object

10 Behavioral Patterns 1. Chain of Responsibility: Pass requests between command and processing objects within a chain of objects 2. Command: Encapsulate a method call as an object containing all necessary information 3. Interpreter: Include language elements and evaluate sentences in a given language 4. Iterator: Give sequential access to elements in a collection 5. Mediator: Encapsulates and simplifies communication between objects 6. Memento: Undo modifications and restore an object to its initial state 7. Observer: Notify dependent objects of state changes 8. State: Change object behavior depending on its state 9. Strategy: Encapsulate algorithms within a class and make them interchangeable 10. Template Method: Define an algorithm skeleton and delegate algorithm steps to subclasses so that they may be overridden 11. Visitor: Add new operations to classes without modifying them

11 Singleton Pattern Singleton pattern creates a class which can have a single object throughout the application, so that whenever any other object tries to access the object of the class, it will access the same object always.

12 Singleton 1. What if you want to make sure that a class has only one instance? 2. One possibility is global variables. 3. Another is using static member functions. 4. Best solution: store single instance in static member variable

13 An implementation of the singleton pattern must: 1. ensure that only one instance of the singleton class ever exists; 2. provide global access to that instance. Typically, this is done by: 1. declaring all constructors of the class to be private; 2. providing a static method that returns a reference to the instance. 3. The instance is usually stored as a private static variable; 4. the instance is created when the variable is initialized, at some point before the static method is first called.

14 public sealed class Singleton private static final Singleton INSTANCE = new Singleton(); private Singleton() public static Singleton getinstance() return INSTANCE;

15 public sealed class Singleton private static Singleton instance; private Singleton() public static Singleton Instance get if (instance == null) instance = new Singleton(); return instance;

16 /// <summary> /// Implementation of Singleton Pattern /// </summary> public sealed class SingleTon private static SingleTon _instance =null; private SingleTon() // Made default constructor as private /// <summary> /// Single Instance /// </summary> public static SingleTon Instance get lock (_instance) if(_instance == null) _instance = new SingleTon(); return _instance; //Add As many method as u want here as instance member. No need to make them static.

17 Task 1. Consider the application which uses for diagnostic event log. 2. The log should have methods for add an entry, giving it its content, get an entry and get all entries 3. Each component can be obtained at any time access to the log, so it must be available globally. 4. This event log decides where entry is actually saved. The component only needs to communicate its content. This implies the existence of a single instance of the log. 5. From the event log can also use reusable components, therefore they should not be dependent on resource sharing mechanisms are specific to a given application. 6. We can ensure this by implementing a log singleton pattern so that it can on its own to manage access to himself 7. To test design some class for example student with some methods and each of using method should be logged in event log. You have to log exceptions and notices.

18 Factory Patterns Factory pattern deals with the instantiation of object without exposing the instantiation logic. In other words, a Factory is actually a creator of object which has common interface. Types of factory patterns: 1. Factory Pattern 2. Factory Method Pattern 3. Abstract Factory Design Pattern

19 Factory Patterns -example

20 Factory Patterns -example public interface IPeople string GetName(); public class Villagers : IPeople public string GetName() return "Village Guy"; public class CityPeople : IPeople public string GetName() return "City Guy"; public enum PeopleType RURAL, URBAN

21 Factory Patterns -example public class Factory public IPeople GetPeople(PeopleType type) IPeople people = null; switch (type) case PeopleType.RURAL : people = new Villagers(); break; case PeopleType.URBAN: people = new CityPeople(); break; default: break; return people;

22 Factory Method Pattern What is Factory Method Pattern? In Factory pattern, we create object without exposing the creation logic. In this pattern, an interface is used for creating an object, but let subclass decide which class to instantiate. The creation of object is done when it is required. The Factory method allows a class later instantiation to subclasses. A Factory method is just an addition to Factory class. It creates the object of the class through interfaces but on the other hand, it also lets the subclass to decide which class to be instantiated.

23 The classes, interfaces and objects in the above class diagram are as follows: 1. Product - This is an interface for creating the objects. 2. ConcreteProduct - This is a class which implements the Product interface. 3. Creator - This is an abstract class and declares the factory method, which returns an object of type Product. 4. ConcreteCreator - This is a class which implements the Creator class and overrides the factory method to return an instance of a ConcreteProduct.

24 interface Product class ConcreteProductA : Product class ConcreteProductB : Product abstract class Creator public abstract Product FactoryMethod(string type); class ConcreteCreator : Creator public override Product FactoryMethod(string type) switch (type) case "A": return new ConcreteProductA(); case "B": return new ConcreteProductB(); default: throw new ArgumentException("Invalid type", "type");

25 Factory Method Design Pattern When to use it? 1. Subclasses figure out what objects should be created. 2. Parent class allows later instantiation to subclasses means the creation of object is done when it is required. 3. The process of objects creation is required to centralize within the application. 4. A class (creator) will not know what classes it will be required to create.

26 Abstract Factory Design Pattern What is Abstract Factory Pattern? Abstract Factory patterns acts a super-factory which creates other factories. This pattern is also called as Factory of factories. In Abstract Factory pattern an interface is responsible for creating a set of related objects, or dependent objects without specifying their concrete classes. Abstract factory is the extension of basic Factory pattern. It provides Factory interfaces for creating a family of related classes.

27 Abstract Factory Design Pattern

28 Abstract Factory Design Pattern The classes, interfaces and objects in the above class diagram are as follows: 1. AbstractFactory - This is an interface which is used to create abstract product 2. ConcreteFactory -This is a class which implements the AbstractFactory interface to create concrete products. 3. AbstractProduct - This is an interface which declares a type of product. 4. ConcreteProduct -This is a class which implements the AbstractProduct interface to create product. 5. Client - This is a class which use AbstractFactory and AbstractProduct interfaces to create a family of related objects.

29 Abstract Factory Design Pattern - Example public interface AbstractFactory AbstractProductA CreateProductA(); AbstractProductB CreateProductB(); public class ConcreteFactoryA : AbstractFactory public AbstractProductA CreateProductA() return new ProductA1(); public AbstractProductB CreateProductB() return new ProductB1(); public class ConcreteFactoryB : AbstractFactory public AbstractProductA CreateProductA() return new ProductA2(); public AbstractProductB CreateProductB() return new ProductB2();

30 Abstract Factory Design Pattern - Example public interface AbstractProductA public interface AbstractProductB public class ProductA1 : AbstractProductA public class ProductA2 : AbstractProductA public class ProductB1 : AbstractProductB public class ProductB2 : AbstractProductB public class Client private AbstractProductA _producta; private AbstractProductB _productb; public Client(AbstractFactory factory) _producta = factory.createproducta(); _productb = factory.createproductb();

31 Abstract Factory Design Pattern - Example Pattern&referringTitle=Home

32 END