Boost Your C# With Structural And Creational Design Patterns

The abstract factory pattern is ideal for constructing families of interrelated products. The pattern provides factories for constructing new objects and guarantees that each factory can only create objects that are compatible.

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 abstract factories to simulate an ecosystem in Africa and Australia.

The builder pattern is intended for constructing aggregate objects. These are objects that consist of a collection of internal parts. The pattern makes it very easy to build new objects by adding parts one at a time.

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 automates a fast-food restaurant and uses the builder pattern to assemble burger- and kids menus.

The factory method pattern provides an abstract virtual object constructor that you can override in subclasses. This gives you full control over the object creation process, in contrast to the 'new' operator which always creates a new instance of the given type.

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 some code that uses the factory method pattern to automate a plastic toy factory.

The prototype design pattern uses a pre-built prototype object to quickly create new objects. This can be very useful if the object creation process is expensive in terms of time and memory.

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 image generation program that uses a prototype object to quickly create a collection of related images.

The singleton pattern ensures that there can only ever be one single instance of a given class. This can be very useful for providing system-wide access to some kind of application support service.

In this lecture I'll show you how you can implement the pattern in your own code, and I will explain how this pattern became the most abused design pattern in the world. I will also show you how to build a simple diagnostic logger with the singleton pattern.

Congratulations on finishing this section. This is a recap of what we have learned.

The adapter pattern lets you incorporate a legacy component into your application architecture that no longer supports the legacy interface. The pattern provides a special adapter class that can communicate both with the application architecture and with the legacy component.

I will show you a legacy stock price history library that uses decimal arrays, and then demonstrate how the adapter pattern can be used to make this library compatible with an application architecture that uses DataTables everywhere.

If you try to combine two orthogonal class hierarchies together, your application architecture will quickly devolve into a mess of duplicated classes spread out all over your object hierarchy. The bridge pattern solves this problem by keeping the two hierarchies completely separate, and connecting them with a single bridge.

I will show you how you can use the bridge pattern to create a very elegant and compact charting library that draws lines, squares and rectangles on various output devices.

The composite pattern is intended for building tree-like data structures. It allows you to nest component classes inside other component classes to build a tree structure.

I will demonstrate the pattern by building a simple web rendering library that output the correct HTML code for simple web documents.

The decorator pattern lets you enhance the functionality of an existing object by layering an arbitrary number of decorators objects on top of each class method. Each decorator can add custom enhancements to the default functionality.

I will demonstrate the pattern by building a simple program that calculates the price of pizza's with various extra toppings.

The facade pattern reduces the learning curve of a complex subsystem by layering a high level interface on top of the low level subsystem interface.

I will demonstrate the pattern by showing you a complex banking subsystem for managing bank accounts and buying equity on the stock market. I will build a facade that implements a mutual fund with a single high level 'Buy' method.

The flyweight pattern allows you to create very large data structures, by elegantly sharing object instances between nodes in the data structure. For example, the pattern can be used to reduce the number of leaf object instances in the composite pattern.

I will show you a simple web rendering library that loads images to display in a web page. The library uses the flyweight pattern to prevent the same image from being loaded twice.

The proxy pattern allows you to lazily instantiate an object at the last possible moment. Another use is with remoting, where the proxy acts as a surrogate for a remote object. And lastly you can use proxies to wrap access control code around an existing object.

I will show you how to use a proxy to implement a simple rate limiter around a web service API. The rate limiter restricts the number of API calls to one per second.

Congratulations on finishing this section. This is a recap of what we have learned.