Objective

Design patterns are reusable solutions that solve the challenges software developers face over and over again. Rather than reinventing the wheel, learn how to make use of these proven and tested patterns that will make your software more reliable and flexible to change. This course will introduce you to design patterns and take you through 16 of the most used object-oriented patterns that will make your development faster and easier.

We introduce Object Oriented Programming fundamentals through GRASP Patterns, then we deeply explore the famous SOLID principles.

We analyze the most useful Design Patterns from the classic GoF Design Patterns book and discuss the SOLID principles in the context of the patterns. Each pattern has several sample codes which helps understanding the pattern in real world usage.

There are several lab exercises (in C#) to really grasp the ideas of the patterns.

The main value of the course is not simply the introduction of the Design Patterns, but the fact it can help the programmers to think in object-oriented manner, consciously decide about the tradeoffs of a design decision.

The course is available in the following programming languages: C#.

Participants

Architects, software developers with minimum 3 year C# background or years of practice in other programing languages (lots of C++ programmers successfully completed this couse too).

Content

This course is mainly constructed for C# .NET programmers who need to learn real-world Object Oriented Design.

Modules

GRASP Patterns

General responsibility assignment software patterns (or principles), abbreviated GRASP, consist of guidelines for assigning responsibility to classes and objects in object-oriented design.

During this module the participants understand the basic principles of Object Oriented Programming. The patterns are actualized by introducing how we think differently about some of the patterns nowadays.

Key topics during this section: Information Expert, Creator, Cohesion, Coupling, Controller, Polymorphism, Indirection, Protected Variations and Pure Fabrication.

SOLID Principles

SOLID is a mnemonic acronym for five design principles intended to make software designs more understandable, flexible and maintainable. We deeply discuss how these principles make a better software design, and how can we analyze a design quality by these tenets.

Key topics during this module: Single Responsibility, Open-Closed Principle, Liskov Substitution Principle, Interface Segregation, Dependency Inversion.

Bridge pattern

Deriving the Bridge Pattern from ground-up based on a Drawing Editor example. Examining the Bridge Pattern in detail. Examples from the .NET Framework.

Lab: Refactoring a badly designed multi-database sample application to Bridge.

Template Method

Examining the Template Method in detail. Examples from the .NET Framework.

Lab: Refactoring the previous example to remove duplication by introducing Template Method pattern on both sides of the Bridge.

Sample codes: Sorting using IComparable, event handling callers in .NET, webpage input validation using Layer Supertype + Template Method patterns.

Strategy

Examining the Strategy pattern in detail. Examples from the .NET Framework.

Sample codes: Sorting using IComparer, user input validators, Multi-Step Etl process using Strategy pattern.

Factory Method

Examining the Factory Method pattern in detail. Examples from the .NET Framework.

Sample codes: different kind of factories.

Abstract Factory

Examining the Abstract Factory pattern in detail. Examples from the .NET Framework.

Sample codes: Concrete Factories, Abstract Database object Factory

Decorator

Examining the Decorator pattern in detail. Examples from the .NET Framework.

Sample codes: changing collection responsibilities using decorators.

Lab: refactoring a wrong Visual Decorator hierarchy to become conform to the canonical pattern structure.

Adapter

Examining the Adapter pattern in detail. Examples from the .NET Framework.

Sample codes: adapter to adapt anything to IDataReader for bulk sql server insert. A reusable tree view control as a pluggable adapter example. Adapting anything to IListSource sample.

Iterator

Examining the Iterator pattern in detail. Examples from the .NET Framework.

Sample codes: creating external iterator to recursive structures using custom stack, creating recursive iterator using C# yield support, creating generators and transformations using yields, creating a Where filter using yield. Creating internal iterator to a linked list. Versioned iterator concept demo.

Lab: creating external iterator for a linked list.  

Composite

Examining the Composite pattern in detail. Examples from the .NET Framework.

Sample code: file system simulation using the Composite Pattern. Handling parent references. Lowering memory requirements by using data dictionaries.

Lab: adding Size property to the composite structure.

Visitor

Examining the Visitor pattern in detail. Examples from the .NET Framework.

Sample code: File Composite made extensible by Visitor, Expression visitor by C# dynamic support. Expression AST transformation using Visitor. Code examination and transformation using Roslyn.

Singleton

Examining the Singleton (anti)pattern in detail. Examples from the .NET Framework.

Sample codes: Simple singleton, making singleton thread safe, BeforeFieldInit, modelling business rules complex sample which uses singleton and other patterns.

Command

Examining the Command pattern in detail. Examples from the .NET Framework.

Sample code: implementing undo-redo for a tree editor.

Observer

Examining the Observer pattern in detail. Examples from the .NET Framework.

Sample code: INotifyPropertyChanged implementation details.

Chain of Responsibility

Examining the Chain of Responsibility pattern in detail. Examples from the .NET Framework.

Sample codes: Chain of Responsibility variations, Loan processing, Middlewares in OWIN, Handlers in WebAPI.

Builder

Examining the Builder pattern in detail. Examples from the .NET Framework.

Sample code: Fluent style builders. Building source code using CodeDom. Building a state machine using fluent builders.

State

Examining the State pattern in detail. Examples from the .NET Framework

Sample code: CSV reader..

Other Patterns

Explore the remaining patterns briefly: Prototype, Facade, Flyweight, Proxy, Interpreter, Mediator, Memento.

Misc.

• Classroom with computers is required
• Hungarian handout and the source code of the demo applications will be provided for the participants.
• 2 whiteboards and a beamer with HDMI is required.