The easiest way to learn design patterns

The easiest way to learn design patterns, available at $54.99, has an average rating of 3.78, with 126 lectures, 3 quizzes, based on 9 reviews, and has 415 subscribers.

You will learn about Learn SOLID principles Learn the situations where design patterns are appropriate Learn how to implement individual design patterns in C# Learn how to apply design patterns in a real-life situation This course is ideal for individuals who are C# developers that want to learn how to solve problems more effectively It is particularly useful for C# developers that want to learn how to solve problems more effectively.

Enroll now: The easiest way to learn design patterns

Summary

Title: The easiest way to learn design patterns

Price: $54.99

Average Rating: 3.78

Number of Lectures: 126

Number of Quizzes: 3

Number of Published Lectures: 126

Number of Published Quizzes: 3

Number of Curriculum Items: 129

Number of Published Curriculum Objects: 129

Original Price: $29.99

Quality Status: approved

Status: Live

What You Will Learn

Learn SOLID principles
Learn the situations where design patterns are appropriate
Learn how to implement individual design patterns in C#
Learn how to apply design patterns in a real-life situation

Who Should Attend

C# developers that want to learn how to solve problems more effectively

Target Audiences

C# developers that want to learn how to solve problems more effectively

Design patters are something that you will need to get familiar with as a programmer who works with object oriented languages. And this is primarily because they represent well-defined solutions to common software development problems. So, instead of thinking through all the details of your solution, you can simply check if any of the existing design patterns can be used. You won’t have to reinvent the wheel.

The main problem with design patterns is that they are not necessarily easy to learn. Many developers, especially the ones who don’t have a lot of software-building experience, struggle with them. But if you do struggle with them, it may prevent you from getting a programming job at a reputable organization. After all, recruiting managers often ask questions about design patterns. Otherwise, not knowing design patterns will make you less effective as a software developer, which will slow down your career progress.

The main reason why design patterns are so hard to learn is because of the way they are normally taught. Usually, if you pick pretty much any course on design patterns or open pretty much any online article about them, it would provide a collection of design patterns that you would need to go through. You would then have to got through each of them, try your best to understand the principles behind it and only then try to figure out how to apply it in a real-life situation.

It’s a tedious process that doesn’t always bring about the right results. It’s not uncommon for software developers to memorize just a handful of design patterns that they have been using in their own projects. The remaining ones have been forgotten as soon as they’ve been learned. And it’s hard to figure out which design pattern applies in which situation if you only remember a handful of them.

This course provides a different approach. It uses a methodology that makes it easy to learn design patterns. So, you no longer have to brute-force your way through them. The process of effective learning is not about memorization. It’s about associations. You learn new things easily when you can clearly see how new facts related to your existing knowledge. And this is precisely the method that this course is built around.

You won’t have to brute-force your way into design patterns. In fact, you won’t even start with the design patterns. First, we will go through a list of common problems that software developers are required to solve. Those are the things that every software developer can associate with. Even if you haven’t faced a particular type of a problem yet, you will still be able to easily understand its description. For each of these problems, we will go through the design patterns that can solve it. And for each one of them, you will go through its core principle and the description of how it can solve this type of a problem. Only then you will be invited to examine this particular design pattern in detail, so you can understand how to implement it in your own code.

This structure of the course also makes it valuable as a reference source. Even when you don’t know or don’t remember design patterns, looking them up becomes easy. What you need to find is a description of the type of a problem you are trying to solve. And then you will be able to follow it to find the actual design patterns that you can apply to solve it.

Course Curriculum

Chapter 1: Introduction

Lecture 1: About the author and his mission

Lecture 2: Introduction to design pattern

Lecture 3: Course prerequisites

Chapter 2: SOLID principles

Lecture 1: Why SOLID principles are important

Lecture 2: Preparing the initial code

Lecture 3: Overview of the initial code

Lecture 4: Get started with single responsibility principle

Lecture 5: Single responsibility principle explained

Lecture 6: Get started with open closed principle

Lecture 7: Open closed principle explained

Lecture 8: Get started with Liskov substitution principle

Lecture 9: Liskov substitution principle explained

Lecture 10: Get started with interface segregation principle

Lecture 11: Interface segregation principle explained

Lecture 12: Get started with dependency inversion principle

Lecture 13: Dependency inversion principle explained

Lecture 14: SOLID principles summary

Chapter 3: The problems that design patterns are intended to solve

Lecture 1: Introduction to the section

Lecture 2: Not knowing what object implementations you'll need ahead of time

Lecture 3: Making several exact copies of a complex object

Lecture 4: Using many instances of an object while keeping code running smoothly

Lecture 5: Using the same single instance of an object throughout the application

Lecture 6: Third party components aren’t directly compatible with your code

Lecture 7: Adding new functionality to existing objects that cannot be modified

Lecture 8: Accessing complex back-end logic from the presentation layer

Lecture 9: User interface and business logic are developed separately

Lecture 10: Building a complex object hierarchy

Lecture 11: Implementing complex conditional logic

Lecture 12: Multiple object instances of different types need to be able to communicate with

Lecture 13: Multiple stages of processing are needed

Lecture 14: The system is controlled by complex combinations of inputs

Lecture 15: Ability to undo an action that has been applied

Lecture 16: Ability to traverse a collection without knowing its underlying structure

Lecture 17: Creating a family of related algorithms

Lecture 18: Summary of the problems design patterns are intended to solve

Chapter 4: Design patterns demonstrated in C#

Lecture 1: Introduction to design patterns

Lecture 2: Factory Method overview

Lecture 3: Factory Method example

Lecture 4: Factory Method explained

Lecture 5: Pros and cons of using Factory Method

Lecture 6: Abstract Factory overview

Lecture 7: Abstract Factory example

Lecture 8: Abstract Factory explained

Lecture 9: Pros and cons of using Abstract Factory

Lecture 10: Builder Overview

Lecture 11: Builder example

Lecture 12: Builder explained

Lecture 13: Pros and cons of using Builder

Lecture 14: Prototype overview

Lecture 15: Prototype example

Lecture 16: Prototype explained

Lecture 17: Pros and cons of using Prototype

Lecture 18: Singleton overview

Lecture 19: Singleton example

Lecture 20: Singleton explained

Lecture 21: Pros and cons of using Singleton

Lecture 22: Adapter overview

Lecture 23: Adapter example

Lecture 24: Adapter explained

Lecture 25: Pros and cons of using Adapter

Lecture 26: Bridge overview

Lecture 27: Bridge example

Lecture 28: Bridge explained

Lecture 29: Pros and cons of using Bridge

Lecture 30: Composite overview

Lecture 31: Composite example

Lecture 32: Composite explained

Lecture 33: Pros and cons of using Composite

Lecture 34: Decorator overview

Lecture 35: Decorator example

Lecture 36: Decorator explained

Lecture 37: Pros and cons of using Decorator

Lecture 38: Facade overview

Lecture 39: Facade example

Lecture 40: Facade explained

Lecture 41: Pros and cons of using Facade

Lecture 42: Flyweight overview

Lecture 43: Flyweight example

Lecture 44: Flyweight explained

Lecture 45: Pros and cons of using Flyweight

Lecture 46: Proxy overview

Lecture 47: Proxy example

Lecture 48: Proxy explained

Lecture 49: Pros and cons of using Proxy

Lecture 50: Chain of Responsibility overview

Lecture 51: Chain of Responsibility example

Lecture 52: Chain of Responsibility explained

Lecture 53: Pros and cons of using Chain of Responsibility

Lecture 54: Command overview

Lecture 55: Command example

Lecture 56: Command explained

Lecture 57: Pros and cons of using Command

Lecture 58: Iterator overview

Lecture 59: Iterator example

Instructors

Fiodar Sazanavets
Full stack senior software developer specializing in .NET

Rating Distribution

1 stars: 1 votes
2 stars: 1 votes
3 stars: 1 votes
4 stars: 4 votes
5 stars: 2 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!

Menu