Mô tả

More than two decades since design patterns have appeared, many developers consider them the most important discovery in software development. Others still find them a bad idea. And both are right! How comes?

In this course, you will learn how design patterns can be applied to make code better: flexible, short, readable. Flexibility is the key element in design patterns. You will learn how to decide when and which pattern to apply by formally analyzing the need to flex around specific axis. You will learn which pattern is adding which kind of flexibility, and what are the most common forms of implementation in practice. You will also learn common pitfalls and ways to overcome them when applying specific patterns.

Through a series of demonstrations, you will learn one design pattern at a time. In each demonstration, we shall start from an existing implementation which faces difficulties to accommodate the next requirement proposed by the customer. That will invariantly trigger a series of designing attempts, some doomed to fail, others having prospect to succeed. But what will learn in this course, is that each successful design will exhibit one kind of flexibility, which will be of critical importance to support the troublesome request posed by the customer. It will come as no surprise to you to learn that each such special kind of flexibility will be one specific design pattern.

Bạn sẽ học được gì

How to apply design patterns to help simplify application design

How to reduce design complexity by moving responsibilities into collaborating classes

Yêu cầu

  • Fair understanding of the C# programming language
  • Working knowledge of software design
  • Any knowledge of design patterns is a plus

Nội dung khoá học

9 sections

Introduction

2 lectures
Understanding the Role of Design Patterns
13:42
How This Course Is Structured
04:43

Adding Behavior to an Object with the Decorator Pattern

6 lectures
Motivation for the Decorator Pattern
06:56
The First Attempt to Decorate a Class
08:50
The Downfall of the Subclassing Decorator
07:26
Using Object Composition Instead of Inheritance
08:32
Summary
02:09
Decorator pattern questions
5 questions

Adapting to a Different Interface with the Adapter Pattern

6 lectures
Advancing from Decorator to Adapter Pattern
07:31
Implementing a Transparent Adapter
06:00
Towards a Heavyweight Adapter
07:02
Limiting the Role of Adapters
07:12
Summary
02:42
Adapter pattern questions
5 questions

Constructing Flexible Behavior with the Strategy Pattern

9 lectures
Understanding the Need for Flexibility
06:40
Implementing the Strategy Pattern
06:09
Implementing Strategies via the Interface
06:00
Augmenting the Strategy Interface
05:54
Demonstrating the Power of Strategies
04:40
Implementing Strategies with Strategies
05:03
Strategies in the .NET Framework
03:42
Summary
02:03
Strategy pattern questions
6 questions

Decoupling Classes with the Abstract Factory Pattern

8 lectures
Understanding the Need for Abstract Factory Pattern
06:32
Understanding the Limitations of the Abstract Factory
04:14
Attempting to Overcome the Limitations
03:50
Implementing Concrete Factories
05:37
Completing the Concrete Factories
05:02
Demonstrating the Concrete Factories
07:30
Summary
02:39
Abstract Factory pattern questions
5 questions

Constructing Objects on the Fly with the Factory Method Pattern

6 lectures
From Abstract Factory to Factory Method
06:41
Holding State Behind a Factory Method
04:56
Fixing Parameters with Factory Method
05:44
Confining Propagation of Change with Factory Methods
08:14
Currying Factory Methods
05:19
Summary
02:17

Encapsulating Construction Rules with the Builder Pattern

6 lectures
Understanding Limitations of Factories
07:26
Replacing Factory with Builder
04:40
Adding Validation to the Builder
06:13
Handling Variation and Optional Components
07:28
Building a Factory Method
04:53
Summary
03:14

Constructing Complex Objects with the Builder Pattern

8 lectures
Building a Graph of Objects
07:38
Understanding the Need for a Consistent Builder
03:42
Designing a Consistent Builder
03:39
Adding Alternatives to a Consistent Builder
06:54
Designing a Fluent Builder
07:25
Designing an Immutable Builder
03:54
Shameless Immutability in Builders
04:50
Summary
03:11

Treating Collection as an Object with the Composite Pattern

7 lectures
Understanding Multitudes of Objects
05:58
Inventing the Composite Element
05:44
Understanding Recursive Nature of Composites
05:36
Combining Composite and Factory Methods
03:18
Combining Composite and Abstract Factory
04:53
Reversing Composites: Representing One Element as Many
06:42
Summary
02:28

Đánh giá của học viên

Chưa có đánh giá
Course Rating
5
0%
4
0%
3
0%
2
0%
1
0%

Bình luận khách hàng

Viết Bình Luận

Bạn đánh giá khoá học này thế nào?

image

Đăng ký get khoá học Udemy - Unica - Gitiho giá chỉ 50k!

Get khoá học giá rẻ ngay trước khi bị fix.