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 final 11 design patterns. These are all behavioural design patterns. You use these patterns to structure how the different parts of your application architecture interact with each other.
By the end of the course you will be fluent in all 11 behavioural 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. 'Visitor') 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 3.5 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 will tell a bit more about myself, my career, and my motivation to become an online trainer.
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 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.
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.