Refactoring to Design Patterns by Example
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
1,585 students enrolled
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
Featured review
Saikalyan Akunuri
(
6 courses,
3 reviews
)
8 months ago
Perfect. Its very practical and the live example makes it much more easier to relate. I am doing the refactoring along with the session and that helps understand the concept much better rather than just watching the refactoring
Course content
Expand all
51 lectures
04:25:51
+
–
Recognizing the Need for Refactoring and Design Patterns
5 lectures
32:25
Identifying Current Factoring of an Application
05:33
Identifying Refactoring Targets
07:35
Summary
02:14
+
–
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