Buying for a Team? Gift This Course
Wishlisted Wishlist

Please confirm that you want to add Boost Your C# With Behavioural Design Patterns to your Wishlist.

Add to Wishlist

Boost Your C# With Behavioural Design Patterns

A complete guide to the final 11 behavioural design patterns from the famous book by the Gang Of Four.
4.5 (40 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
783 students enrolled
Created by Mark Farragher
Last updated 12/2015
$10 $90 89% off
19 hours left at this price!
30-Day Money-Back Guarantee
  • 3.5 hours on-demand video
  • 11 Supplemental Resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Have a coupon?
What Will I Learn?
Learn 11 fundamental C# design patterns from a certified Microsoft trainer from your own desk.
Many hours of video content teaching you about visitors, observers, mediators, interpreters, commands, and much more!
Suitable for beginner and intermediate programmers and ideal for users who learn faster when shown.
Learn the intent and benefits of each design pattern.
Includes 11 source code templates that you can copy and paste into your own applications.
Understand the pros and cons of using observers, mediators, and the state pattern.
Contains many real-world examples that use patterns to solve an actual business problem.
View Curriculum
  • You should have a Windows, Mac or Linux laptop with Microsoft Visual Studio, Xamarin Studio or Monodevelop installed
  • You should be familiar with the C# language
  • That's all!

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".

So how’s your IT career going? Are you a software developer? Or maybe the team lead?

Well, how does Senior Application Architect sound? This job means you get to design the application architectures, and the dev team gets to implement all of your designs. A pretty sweet deal (plus there’s usually a nice paycheque).

But if you want to become a software architect you simply have to know all fundamental design patterns by heart, there's no excuse. Detailed knowledge of all of these fundamental patterns will greatly benefit your career.

Are you ready to give your IT career a huge boost?

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.

Act now

This course today contains over 3.5 hours of video content. Enrol now to benefit from the current price and get free lifelong access to all future materials.

Enrol now!

Who is the target audience?
  • This course is for beginner and intermediate C# programmers who want to learn the fundamental design patterns from the "Gang of Four".
  • Ideal for students who are about to take a job interview, and need to prepare for software architecture questions.
  • Are you designing the software architecture of a large C# project? Then this course is for you!
Students Who Viewed This Course Also Viewed
Curriculum For This Course
Expand All 18 Lectures Collapse All 18 Lectures 03:39:26
4 Lectures 17:00
In this lecture I explain how this course is organised and I describe each of the upcoming sections in detail.
Preview 04:46

In this lecture I will tell a bit more about myself, my career, and my motivation to become an online trainer.

Preview 03:50

In this lecture we're going to take a closer look at Design Patterns, and what they can do for you.

Preview 05:05

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.

Preview 03:19
Behavioural Design Patterns
13 Lectures 03:19:33
Welcome to the Behavioural Design Patterns section. I will give a quick introduction on how the section is organized before we get started.
Section Introduction

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.

Chain Of Responsibility Pattern

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.

Command Pattern

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.

Interpreter Pattern

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.

Iterator Pattern

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.

Mediator Pattern

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.

Memento Pattern

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.

Observer Pattern

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.

Preview 17:26

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.

Strategy Pattern

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.

Template Method Pattern

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.

Visitor Pattern

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

Behavioural Design Patterns
11 questions
Final Words
1 Lecture 02:53
In this lecture I would like to thank you for finishing the course and offer some final words.
Course Recap
About the Instructor
4.4 Average rating
659 Reviews
4,407 Students
9 Courses
Microsoft Certified Trainer - C# and .NET

Hi I'm Mark, and I am very pleased to meet you!

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.

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. 

Report Abuse