🗊Презентация Design patterns. GoF for .Net developers

Design patterns GoF for .Net Developers

Agenda History What is patterns? The most uses GoF patterns: Singleton; Factory Method; Abstract Factory; Builder; Adapter; Bridge; Facade; Composite; Iterator.

History

History Patterns originated as an architectural concept by Christopher Alexander (1977/79). In 1987, Kent Beck and Ward Cunningham began experimenting with the idea of applying patterns to programming – specifically pattern languages – and presented their results at the OOPSLA conference that year. In the following years, Beck, Cunningham and others followed up on this work. Design patterns gained popularity in computer science after the book Design Patterns: Elements of Reusable Object-Oriented Software was published in 1994 by the so-called "Gang of Four" (Gamma et al.), which is frequently abbreviated as “GoF". Although design patterns have been applied practically for a long time, formalization of the concept of design patterns languished for several years.

What is patterns?

What is patterns? Design patterns represent the best practices used by experienced object-oriented software developers. Design patterns are solutions to general problems that software developers faced during software development. These solutions were obtained by trial and error by numerous software developers over quite a substantial period of time. Design pattern – a description of the interaction of objects and classes that are adapted to solve the general problem of designing in context.

What is patterns? Any pattern describes the problem that arises again and again in our work. In general, pattern consists of four main elements: Name. Referring to it, we can immediately describe the problem, designing of, and its decisions and their consequences. Assigning names of patterns allows design at a higher level of abstraction. Problem. A description of when to apply the pattern. Necessary to formulate the problem and its context. Solution. Description of design elements, relations between them, the functions each item. The Results – a consequence of the pattern. In describing the impact of design decisions are often not mentioned. You must choose between different options and evaluate the advantages and disadvantages of the pattern.

What is patterns? Design Patterns are divided into groups Creational patterns are ones that create objects for you, rather than having you instantiate objects directly. This gives your program more flexibility in deciding which objects need to be created for a given case. Abstract Factory groups object factories that have a common theme. Builder constructs complex objects by separating construction and representation. Factory Method creates objects without specifying the exact class to create. Prototype creates objects by cloning an existing object. Singleton restricts object creation for a class to only one instance. Behavioral patterns. Most of these design patterns are specifically concerned with communication between objects. Chain of responsibility delegates commands to a chain of processing objects. Iterator accesses the elements of an object sequentially without exposing its underlying representation. Observer is a publish/subscribe pattern which allows a number of observer objects to see an event.

What is patterns? Structural patterns. These concern class and object composition. They use inheritance to compose interfaces and define ways to compose objects to obtain new functionality. Adapter allows classes with incompatible interfaces to work together by wrapping its own interface around that of an already existing class. Bridge decouples an abstraction from its implementation so that the two can vary independently. Composite composes zero-or-more similar objects so that they can be manipulated as one object. Decorator dynamically adds/overrides behaviour in an existing method of an object. Facade provides a simplified interface to a large body of code. Proxy provides a placeholder for another object to control access, reduce cost, and reduce complexity. Design patterns reside in the domain of modules and interconnections. At a higher level there are architectural patterns that are larger in scope, usually describing an overall pattern followed by an entire system.

Singleton

Singleton In software engineering, the singleton pattern is a design pattern that restricts the instantiation of a class to one object.

Sigleton: Example

Factory Method

Factory method Factory pattern is one of most used design pattern. In Factory pattern, we create object without exposing the creation logic to the client and refer to newly created object using a common interface.

Factory Method: Example We're going to create a Mechanism interface and concrete classes implementing the Mechanism interface. A factory class MechanismFactory is defined as a next step. MainClass, our demo class will use MechanismFactory to get a Mechanism object. It will pass information (BALLISTA / CATAPULT / TREBUCHET) to MechanismFactory to get the type of object it needs.

Factory Method: Example

Factory Method: Example

Factory Method: Example

Abstract Factory

Abstract Factory Abstract Factory patterns work around a super-factory which creates other factories. In Abstract Factory pattern an interface is responsible for creating a factory of related objects without explicitly specifying their classes. Each generated factory can give the objects as per the Factory pattern.

Abstract Factory: Example We are going to create a Race and Army interfaces and concrete classes implementing these interfaces. We create an abstract factory class AbstractFactory as next step. Factory classes RaceFactory and ArmyFactory are defined where each factory extends AbstractFactory. A factory creator/generator class FactoryProducer is created. MainClass, our demo class uses FactoryProducer to get a AbstractFactory object. It will pass information (ORKS / ELVES / DWARFS for Race) to AbstractFactory to get the type of object it needs. It also passes information (WARIOR / ARCHER / CAVALARY for Army) to AbstractFactory to get the type of object it needs.

Abstract Factory: Example

Abstract Factory: Example

Factory Method: Example

Abstract Factory: Example

Factory Method: Example

Factory Method: Example

Factory Method: Example

Builder

Builder Builder pattern builds a complex object using simple objects and using a step by step approach. This type of design pattern comes under creational pattern as this pattern provides one of the best ways to create an object. A Builder class builds the final object step by step. This builder is independent of other objects.

Builder: Example We have considered a case of army stack forming where a typical army could be a hero and a platoon. Hero could be either a Dwarf or Elf and will be move by a horse. Platoon could be either a Wariors or Archers and will be move afoot. We are going to create an Stack interface representing stack of army such as heros and platoons and concrete classes implementing the Stack interface and a Movement interface representing type of army moving and concrete classes implementing the Movement interface as hero would be move by a horse and platoon would be move afoot. We then create a Army class having List of Stack and a ArmyBuilder to build different types of Army objects by combining Stack. MainClass, our demo class will use ArmyBuilder to build a Army.

Builder: Example

Builder: Example

Builder: Example

Builder: Example

Builder: Example

Builder: Example

Builder: Example

Adapter

Adapter Adapter pattern works as a bridge between two incompatible interfaces. This type of design pattern comes under structural pattern as this pattern combines the capability of two independent interfaces.

Adapter: Example We have a NatureSpells interface and a concrete class Mage implementing the NatureSpells interface. Mage can cast Nature spells by default. We are having another interface MoreSpells and concrete classes implementing the MoreSpells interface. These classes define the other type of spells. We want to make Mage to cast other spells as well. To attain this, we have created an adapter class SpellsAdapter which implements the NatureSpells interface and uses MoreSpells objects to cast the required spell. Mage uses the adapter class SpellsAdapter passing it the desired spell type without knowing the actual class which can cast the desired spell. MainClass, our demo class will use Mage class to play various spells.

Adapter: Example

Adapter: Example

Adapter: Example

Adapter: Example

Bridge

Bridge Bridge is used when we need to decouple an abstraction from its implementation so that the two can vary independently. This type of design pattern comes under structural pattern as this pattern decouples implementation class and abstract class by providing a bridge structure between them. This pattern involves an interface which acts as a bridge which makes the functionality of concrete classes independent from interface implementer classes. Both types of classes can be altered structurally without affecting each other.

Bridge: Example We have a PlatoonAPI interface which is acting as a bridge implementer and concrete classes EliteArcher, SharpShooter implementing the PlatoonAPI interface. Platoon is an abstract class and will use object of PlatoonAPI. MainClass, our demo class will use Platoon class to draw different archer type.

Bridge: Example

Bridge: Example

Facade

Facade Facade pattern hides the complexities of the system and provides an interface to the client using which the client can access the system. This type of design pattern comes under structural pattern as this pattern adds an interface to existing system to hide its complexities.

Facade: Example We are going to create a Hero interface and concrete classes implementing the Hero interface. A facade class HeroeFacade is defined as a next step. HeroeFacade class uses the concrete classes to delegate user calls to these classes. MainClass, our demo class, will use HeroeFacade class to show the results.

Facade: Example

Facade: Example

Facade: Example

Composite

Composite Composite pattern is used where we need to treat a group of objects in similar way as a single object. Composite pattern composes objects in term of a tree structure to represent part as well as whole hierarchy. This type of design pattern comes under structural pattern as this pattern creates a tree structure of group of objects. This pattern creates a class that contains group of its own objects. This class provides ways to modify its group of same objects.

Composite: Example We have a class Heroes which acts as composite pattern actor class. MainClass, our demo class will use Heroes class to add stack of army level hierarchy and print all heroes.

Composite: Example

Composite: Example

…

Iterator

Iterator Iterator pattern is very commonly used design pattern in .Net programming environment. This pattern is used to get a way to access the elements of a collection object in sequential manner without any need to know its underlying representation.

Iterator: Example We're going to create a abstract class Iterator which narrates navigation method and a class HeroesAggregate, implementing abstract class Aggregate, which retruns the iterator HeroesIterator. MainClass, our demo class will use HeroesAggregate, a concrete class implementation to print a Names of heroes stored as a collection in HeroesAggregate.

Iterator: Example

Iterator: Example

Iterator: Example

Thank you!