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.4 (32 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.
648 students enrolled
$19
$90
79% off
Take This Course
  • Lectures 18
  • Length 3.5 hours
  • Skill Level All Levels
  • Languages English
  • Includes Lifetime access
    30 day money back guarantee!
    Available on iOS and Android
    Certificate of Completion
Wishlisted Wishlist

How taking a course works

Discover

Find online courses made by experts from around the world.

Learn

Take your courses with you and learn anywhere, anytime.

Master

Learn and practice real-world skills and achieve your goals.

About This Course

Published 1/2016 English

Course Description

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!

What are the requirements?

  • 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!

What am I going to get from this course?

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

What 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!

What you get with this course?

Not for you? No problem.
30 day money back guarantee.

Forever yours.
Lifetime access.

Learn on the go.
Desktop, iOS and Android.

Get rewarded.
Certificate of completion.

Curriculum

Section 1: Introduction
04:46
In this lecture I explain how this course is organised and I describe each of the upcoming sections in detail.
03:50

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

05:05

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

03:19

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.

Section 2: Behavioural Design Patterns
03:16
Welcome to the Behavioural Design Patterns section. I will give a quick introduction on how the section is organized before we get started.
18:17

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.

15:00

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.

18:11

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.

16:58

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.

16:39

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.

16:31

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.

18:02

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.

17:26

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.

15:10

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.

15:17

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.

16:30

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.

12:16
Congratulations on finishing this section. This is a recap of what we have learned.
Behavioural Design Patterns
11 questions
Section 3: Final Words
02:53
In this lecture I would like to thank you for finishing the course and offer some final words.

Students Who Viewed This Course Also Viewed

  • Loading
  • Loading
  • Loading

Instructor Biography

Mark Farragher, Microsoft Trainer

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've also been a CTO three times.

I started working with 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.

Ready to start learning?
Take This Course