Refactoring to Design Patterns by Example
4.5 (288 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
1,587 students enrolled

Refactoring to Design Patterns by Example

Improving internal design of an existing application with refactoring techniques and design patterns in C#
Bestseller
4.5 (288 ratings)
Course Ratings are calculated from individual students’ ratings and a variety of other signals, like age of rating and reliability, to ensure that they reflect course quality fairly and accurately.
1,585 students enrolled
Created by Zoran Horvat
Last updated 5/2019
English
English
Current price: $20.99 Original price: $29.99 Discount: 30% off
5 hours left at this price!
30-Day Money-Back Guarantee
This course includes
  • 4.5 hours on-demand video
  • 66 downloadable resources
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
Training 5 or more people?

Get your team access to 4,000+ top Udemy courses anytime, anywhere.

Try Udemy for Business
What you'll learn
  • How to apply design patterns while refactoring an existing application
  • How to contain complexity of the business domain while performing small refactoring and redesign steps
Requirements
  • Basic understanding of refactoring
  • Basic working knowledge of design patterns
  • Knowing C# is a plus
Description

This course begins with examination of a realistic application, which is poorly factored and doesn't incorporate design patterns. The demo application converts text into subtitles for videos, which makes it quite useful in practice. Yet, it is nearly impossible to maintain and develop this application further, due to its poor structure and design.

That is the point at which the course begins. As demonstration after demonstration will unfold, we will refactor this entire application, one function and one class at a time. During refactoring, many design patterns will fit into place almost without effort. By the end of the course, you will know how code refactoring and design patterns - one coding practice and one design practice - can operate together and help each other create great design.

Who this course is for:
  • Hands-on programmers who are struggling to keep their source code clean and extensible
  • Programmers who wish to apply design patterns without causing more harm than good
  • All those who wish to improve their object-oriented programming and design skills
Course content
Expand all 51 lectures 04:25:51
+ Deciding Names and Locations for Types
7 lectures 25:35
Understanding Importance of Proper Naming
03:38
Defining the Project Structure
04:27
Implementing the Project Structure
04:11
The Case in Favor of Using Refactoring Tools
02:11
Naming Classes After Concepts They Model
03:42
Naming Classes After Behavior They Offer
05:11
Summary
02:15
+ Decoupling Implementation with Strategies
5 lectures 31:44
Identifying the Need to Decouple Function Calls
05:11
Implementing Stateful Strategies
07:35
Null Object Pattern as a Strategy
08:41
Summary
02:09
+ Chaining Implementation with Composite and Decorator
7 lectures 24:11
Identifying the Need to Group Equally-typed Strategies
02:53
Understanding the Composite Pattern
06:12
Chaining Strategies with Composite Pattern
Processing..
Understanding the Drawbacks of Composite
02:28
Understanding the Decorator Pattern
03:06
Wrapping Strategies with the Decorator Pattern
07:02
Summary
02:30
+ Constructing Complex Object Graphs with Builder
5 lectures 30:54
Identifying the Need for a Builder
07:28
Preparing Ground for the Builder
07:54
Designing the Builder
06:46
A Word about Structuring Namespaces
06:18
Summary
02:28
+ Modeling Low-level Concerns as Infrastructure
5 lectures 32:12
Identifying Infrastructural Concerns
07:58
Introducing the Infrastructure Layer
07:42
Isolating Infrastructural Code
07:49
Moving Infrastructural Code to Another Layer
06:22
Summary
02:21
+ Factoring Domain Complexity Out with the Rules Pattern
6 lectures 34:12
Identifying the Domain Rules
06:19
Preparing Room for Explicit Rules
07:13
Implementing the Rules
07:15
Constructing Composite Rules
04:24
Wrapping Rules into a Rule Adapter
06:03
Summary
02:58
+ Supporting Multiple Transforms with the Visitor Pattern
6 lectures 28:34
Identifying the Need for Unrelated Behaviors
03:56
Introducing the Visitor Design Pattern
08:16
Building Structural Inspection on the Visitor Idea
03:50
Implementing the Structural Inspection Visitor
04:35
Implementing the Concrete Visitor
06:06
Summary
01:51
+ Wrapping It All Together
5 lectures 26:04
Extending the Rules System
05:13
Pushing the Rules System to Its Extreme
04:35
Adding Features to the Domain
05:44
Summary
01:47
Course Summary
08:45