Making Your C# Code More Object-oriented

Making Your C# Code More Object-oriented
Making Your C# Code More Object-oriented
English | MP4 | AVC 1280×720 | AAC 44KHz 2ch | 7h 04m | 1.25 GB

This course will help leverage your conceptual understanding to produce proper object-oriented code, where objects will completely replace procedural code for the sake of flexibility and maintainability.

Programmers do have conceptual understanding of OO concepts, but often fail to turn that into a proper object-oriented code. In this course, Making Your C# Code More Object-oriented, you'll learn how to create proper object-oriented code. First, you'll learn how to avoid branching and looping. Next, you'll learn how to avoid Boolean expressions. Finally, you'll learn how to make domain logic implementation dynamic and configurable. By the end of this course, you'll be able to recognize your own error of the past and build more correct coding style.

Table of Contents

Course Overview
1 Course Overview

Attaining Extensibility with Object-oriented Code
2 What Makes Code Object-oriented
3 What Follows in This Course
4 An Example that Lacks Objects
5 Putting Objects Where It Doesn’t Seem to Be Possible
6 Summary

Rendering Branching Over Boolean Tests Obsolete
7 Introducing the Problem in Code
8 Recognizing the Problem
9 Turning Branching into a Function
10 Turning Function into a State
11 Moving All State-related Code into States
12 Assessing Improvement
13 Summary

Keeping the Focus on Domain Logic with Sequences
14 Understanding the Problem
15 Outlining the Desired Solution
16 Aggregating the Sequence
17 Improving the Readability
18 Improving Performance of Infrastructural Operations
19 Summary

Untangling Structure from Operations on Business Data
20 Identifying the Problem of Selecting an Object
21 Identifying the Problem of Synthesizing an Object
22 Understanding the Problems
23 Treating Collection of Objects as an Object
24 Implementing the Collection of Objects
25 Introducing the Compositional Function Idea
26 Generalized Composition Function
27 Summary

Turning Algorithms into Strategy Objects
28 Identifying the Problem of a Varying Algorithm
29 Dissecting the Algorithm
30 Identifying the Moving Parts of the Algorithm
31 Analysis of the Template Method with Strategy Object
32 Externalizing Strategy to a Separate Class
33 Implementing a Concrete Strategy Class
34 Summary

Using Immutable Objects When Possible
35 Causing a Bug That Comes from a Mutable Object
36 Discovering the Aliasing Bug
37 Fixing the Aliasing Bug
38 Understanding Value Objects
39 Implementing Reference Type as a Value Type
40 Consuming the Immutable Class
41 Turning Immutable Objects into Value Objects
42 Supporting Hash Tables
43 Completing the Equality Tests
44 Mutable vs Immutable vs Value Object
45 Summary

Leveraging Special Case Objects to Remove Null Checks
46 Understanding the Problem of Null
47 Outlining the Design Without Null References
48 How to Never Return Null
49 Demonstrating the Power of Null Objects
50 Introducing Special Cases
51 Turning Boolean Query Methods into Real Operations
52 Substituting Objects at Run Time
53 Summary

Turning Optional Calls into Calls on Optional Objects
54 Complicating the Requirements That Lead to Use of Nulls
55 Identifying the Problem of a Nonexistent Objects
56 Representing Optional Object as a Collection
57 Wrapping a Collection into an Option Type
58 Improving Readability of the Client Code
59 Adding Pattern Matching to Options
60 Heavyweight Implementation of Options with Pattern Matching
61 Demonstrating the Use of Heavyweight Option Type
62 Summary

Increasing Flexibility by Avoiding Switch Statements
63 Adding Requirements that Lead to Multiway Branching
64 Using the Old-fashioned Switch Instruction and an Enum
65 Encapsulating Representation in a Separate Class
66 Using Encapsulated Representation as the Key
67 Turning Multiway Branching into a Dictionary Object
68 Substituting the Multiway Branching Object at Runtime
69 Summary

Turning Chained Branching into the Chain of Rule Objects
70 Implementing Classical Chain of If-Then-Elses
71 Proposing an Object-oriented Design
72 Implementing Concrete Rules
73 Simplifying Implementation Through Refactoring
74 Combining Primitive Rules into Complex Ones
75 Demonstrating the Flexibility of the Chain of Rules
76 Summary

Refactoring to Bind It All Together
77 Introducing an Example
78 Analyzing Initial Implementation
79 Recognizing Infrastructural Code
80 Making Infrastructure Explicit
81 Removing All Infrastructure from Implementation
82 Where to Go with Infrastructural Code
83 Making Profit on Flexibility of Object-oriented Code
84 Summary
85 Course Summary