Boost Your C# With Behavioural Design Patterns

The Chain of responsibility pattern is very useful if your application architecture generates a stream of requests that must be handled by receiver objects, but there is no clear one-on-one mapping between the sender and the receiver of a request.

In this lecture I'll show you how the pattern works and how you can implement it in your own code. I will also demonstrate an example program that uses a chain of responsibility to implement a purchase order approval pipeline.

The Command pattern encapsulate operations as objects, so that you can package operations into self-contained objects and pass them between objects. You use the pattern to implement command logging and undo/redo capabilities.

In this lecture I will explain the pattern and teach you how to implement it in your own code. I will also demonstrate an application that uses commands to implement a calculator with an undo function.

The interpreter pattern provides an interpreter for a domain-specific language (or DSL), with an optional parser to build the expression tree from a language string. A DSL provides a very compact representation for queries, commands or business rules in the given domain.

In this lecture I will demonstrate the pattern and show you how to implement it in your own code. As an example I'll show you an interpreter and parser for the mathematical Reverse-Polish Notation.

The iterator pattern provides sequential access to the elements of a collection without exposing its underlying representation. In the .NET framework iterators are called ‘Enumerators’ and they are pervasive throughout the base class library.

I will demonstrate the pattern by creating a simple class with three integer members, and then implementing an enumerator so that I can sequentially access the members with the foreach statement.

The mediator pattern sets up loose coupling between a group of objects by keeping them from referring to each other directly. Instead all intra-object communication is channeled through a mediator class.

I will demonstrate the pattern by building a simple chat application that uses a mediator to send messages to all visitors of a chatroom.

The memento pattern lets you capture an object's internal state so that it can later be restored to this state. This provides a generic way to capture object state and store it somewhere else.

I will use the pattern to implement a simple document editor, and use memento objects to restore the document to a previous state.

The observer pattern defines a dependency between objects so that when one object changes state all its dependents are notified and updated automatically.

In this lecture I'll show you how the pattern works and how you can implement it in your own code. I will also demonstrate a simple timer that uses an observer to display the current time.

The state pattern lets you alter the behaviour of an object when its internal state changes. This is useful if you have an object that cycles through discrete internal states and the behaviour of the object radically changes with each state transition.

I will use the pattern to implement the software for a candy vending machine.

The strategy pattern defines a family of algorithms, encapsulates them, and makes them interchangeable. This completely shields clients from the implementation details of an algorithm.

In this lecture I'll show you how the pattern works and how you can implement it in your own code. I will also demonstrate how you can use the strategy pattern to quickly parse a list of names using several algorithms.

The template method pattern lets you capture the structure of an algorithm in a template method, and defer the implementation of particular sub-steps of the algorithm to subclasses.

I will use the pattern to append text to an encrypted and an unencrypted file.

The visitor pattern allows you to perform operations on the elements of an object structure without having to perform dynamic type checks.

In this lecture I'll show you how the pattern works and how you can implement it in your own code. I will also demonstrate some code that uses the visitor pattern to quickly partition a product catalog by type.