BEST COURSE CHOICE for beginners and intermediate C# developers who want to take their skills to the next level and learn all Fundamental Software Design Patterns from the "Gang of Four".
In 1994 the "Gang of Four" published a book titled "Design Patterns: Elements of Reusable Object-Oriented Software". This book contains 23 fundamental software design patterns. It is regarded as the standard reference manual for object-oriented design theory and practice.
In this course I will teach you the first 12 design patterns. These are all 5 creational- and all 7 structural design patterns. You use these patterns to create new objects efficiently and to create structure in your application architecture.
By the end of the course you will be fluent in all 12 design patterns. With this knowledge you will be well on your way to become a Senior Application Architect.
Why should you take this course?
You should take this course if you are a beginner or intermediate C# developer and want to take your career to the next level. Some of the patterns (e.g. 'Bridge') might sound very complicated, but all of my lectures are very easy to follow, and I explain all topics with clear code and many instructive diagrams. You'll have no trouble following along.
Or maybe you're working on the application architecture of a large project, and you need to create a robust design that is instantly clear to your team members? The patterns in this course will help you immensely.
Or maybe you're preparing for a C# related job interview? This course will give you an excellent foundation to answer any software architecture questions they might throw at you.
30 day money-back guarantee
This course comes with an unconditional, Udemy backed, 30-day money-back guarantee. If you are dissatisfied with the course for any reason, simply request a refund and get your full purchase amount back, no questions asked.
This course today contains over 4 hours of video content. Enroll now to benefit from the current price and get free lifelong access to all future materials.
In this lecture I explain how this course is organised and I describe each of the upcoming sections in detail.
In this lecture we're going to take a closer look at Design Patterns, and what they can do for you.
Many lectures in this course contain source code examples. Feel free to download the code and follow along. And here's the good news: it doesn't matter if you have a Window, Mac or Linux computer. The code will run on all three operating systems.
In this lecture I demonstrate how my solutions and projects run on all operating systems. I will show you how to build and run the source code on a Mac, on Linux and in Visual Studio running on Windows 8.
At the end of this lecture you will have learned that .NET code is portable and can run on at least five different operating systems.
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.
My IT career spans 2 decades and I've worn many different hats over the years. I am a serial entrepreneur and have launched two startups in The Netherlands.
I started using C# and the .NET framework 15 years ago. Today I live in Barcelona and spend my time creating online courses to share my knowledge of professional C# programming with a wide audience.
I have active MCSA and MCSD certifications plus legacy MCAD and MCT certifications. You can verify my credentials on my LinkedIn profile.
Feel free to check out my course ratings before enrolling. As of today I have 9 published courses, 600+ reviews, and a recent average course rating of 4.41.