Making Your C# Code More Object-oriented

1. 01. Course Overview/1. Course Overview.mp43.66MB
2. 02. Attaining Extensibility with Object-oriented Code/1. What Makes Code Object-oriented.mp410.18MB
3. 02. Attaining Extensibility with Object-oriented Code/2. What Follows in This Course.mp44.76MB
4. 02. Attaining Extensibility with Object-oriented Code/3. An Example that Lacks Objects.mp410.05MB
5. 02. Attaining Extensibility with Object-oriented Code/4. Putting Objects Where It Doesn’t Seem to Be Possible.mp47.99MB
6. 02. Attaining Extensibility with Object-oriented Code/5. Summary.mp41.35MB
7. 03. Rendering Branching Over Boolean Tests Obsolete/1. Introducing the Problem in Code.mp49.22MB
8. 03. Rendering Branching Over Boolean Tests Obsolete/2. Recognizing the Problem.mp419.93MB
9. 03. Rendering Branching Over Boolean Tests Obsolete/3. Turning Branching into a Function.mp417.52MB
10. 03. Rendering Branching Over Boolean Tests Obsolete/4. Turning Function into a State.mp424.93MB
11. 03. Rendering Branching Over Boolean Tests Obsolete/5. Moving All State-related Code into States.mp431.99MB
12. 03. Rendering Branching Over Boolean Tests Obsolete/6. Assessing Improvement.mp416MB
13. 03. Rendering Branching Over Boolean Tests Obsolete/7. Summary.mp43.49MB
14. 04. Keeping the Focus on Domain Logic with Sequences/1. Understanding the Problem.mp411.62MB
15. 04. Keeping the Focus on Domain Logic with Sequences/2. Outlining the Desired Solution.mp412.56MB
16. 04. Keeping the Focus on Domain Logic with Sequences/3. Aggregating the Sequence.mp420.22MB
17. 04. Keeping the Focus on Domain Logic with Sequences/4. Improving the Readability.mp414.49MB
18. 04. Keeping the Focus on Domain Logic with Sequences/5. Improving Performance of Infrastructural Operations.mp411.43MB
19. 04. Keeping the Focus on Domain Logic with Sequences/6. Summary.mp45.17MB
20. 05. Untangling Structure from Operations on Business Data/1. Identifying the Problem of Selecting an Object.mp48.73MB
21. 05. Untangling Structure from Operations on Business Data/2. Identifying the Problem of Synthesizing an Object.mp422.07MB
22. 05. Untangling Structure from Operations on Business Data/3. Understanding the Problems.mp414.84MB
23. 05. Untangling Structure from Operations on Business Data/4. Treating Collection of Objects as an Object.mp414.33MB
24. 05. Untangling Structure from Operations on Business Data/5. Implementing the Collection of Objects.mp418.37MB
25. 05. Untangling Structure from Operations on Business Data/6. Introducing the Compositional Function Idea.mp429.75MB
26. 05. Untangling Structure from Operations on Business Data/7. Generalized Composition Function.mp434.54MB
27. 05. Untangling Structure from Operations on Business Data/8. Summary.mp43.31MB
28. 06. Turning Algorithms into Strategy Objects/1. Identifying the Problem of a Varying Algorithm.mp414.47MB
29. 06. Turning Algorithms into Strategy Objects/2. Dissecting the Algorithm.mp420.36MB
30. 06. Turning Algorithms into Strategy Objects/3. Identifying the Moving Parts of the Algorithm.mp424.71MB
31. 06. Turning Algorithms into Strategy Objects/4. Analysis of the Template Method with Strategy Object.mp413.58MB
32. 06. Turning Algorithms into Strategy Objects/5. Externalizing Strategy to a Separate Class.mp419.69MB
33. 06. Turning Algorithms into Strategy Objects/6. Implementing a Concrete Strategy Class.mp418.98MB
34. 06. Turning Algorithms into Strategy Objects/7. Summary.mp43.24MB
35. 07. Using Immutable Objects When Possible/1. Causing a Bug That Comes from a Mutable Object.mp417.88MB
36. 07. Using Immutable Objects When Possible/10. Mutable vs. Immutable vs. Value Object.mp418.81MB
37. 07. Using Immutable Objects When Possible/11. Summary.mp44.18MB
38. 07. Using Immutable Objects When Possible/2. Discovering the Aliasing Bug.mp418.09MB
39. 07. Using Immutable Objects When Possible/3. Fixing the Aliasing Bug.mp46.71MB
40. 07. Using Immutable Objects When Possible/4. Understanding Value Objects.mp411.73MB
41. 07. Using Immutable Objects When Possible/5. Implementing Reference Type as a Value Type.mp422.64MB
42. 07. Using Immutable Objects When Possible/6. Consuming the Immutable Class.mp413.77MB
43. 07. Using Immutable Objects When Possible/7. Turning Immutable Objects into Value Objects.mp421.12MB
44. 07. Using Immutable Objects When Possible/8. Supporting Hash Tables.mp415.08MB
45. 07. Using Immutable Objects When Possible/9. Completing the Equality Tests.mp417.79MB
46. 08. Leveraging Special Case Objects to Remove Null Checks/1. Understanding the Problem of Null.mp416.51MB
47. 08. Leveraging Special Case Objects to Remove Null Checks/2. Outlining the Design Without Null References.mp46.22MB
48. 08. Leveraging Special Case Objects to Remove Null Checks/3. How to Never Return Null.mp420.44MB
49. 08. Leveraging Special Case Objects to Remove Null Checks/4. Demonstrating the Power of Null Objects.mp420.47MB
50. 08. Leveraging Special Case Objects to Remove Null Checks/5. Introducing Special Cases.mp412.43MB
51. 08. Leveraging Special Case Objects to Remove Null Checks/6. Turning Boolean Query Methods into Real Operations.mp414.87MB
52. 08. Leveraging Special Case Objects to Remove Null Checks/7. Substituting Objects at Run Time.mp416.87MB
53. 08. Leveraging Special Case Objects to Remove Null Checks/8. Summary.mp43.43MB
54. 09. Turning Optional Calls into Calls on Optional Objects/1. Complicating the Requirements That Lead to Use of Nulls.mp414.03MB
55. 09. Turning Optional Calls into Calls on Optional Objects/2. Identifying the Problem of a Nonexistent Objects.mp417.56MB
56. 09. Turning Optional Calls into Calls on Optional Objects/3. Representing Optional Object as a Collection.mp418.2MB
57. 09. Turning Optional Calls into Calls on Optional Objects/4. Wrapping a Collection into an Option Type.mp420.72MB
58. 09. Turning Optional Calls into Calls on Optional Objects/5. Improving Readability of the Client Code.mp44.8MB
59. 09. Turning Optional Calls into Calls on Optional Objects/6. Adding Pattern Matching to Options.mp411.42MB
60. 09. Turning Optional Calls into Calls on Optional Objects/7. Heavyweight Implementation of Options with Pattern Matching.mp419.32MB
61. 09. Turning Optional Calls into Calls on Optional Objects/8. Demonstrating the Use of Heavyweight Option Type.mp417.36MB
62. 09. Turning Optional Calls into Calls on Optional Objects/9. Summary.mp44.22MB
63. 10. Increasing Flexibility by Avoiding Switch Statements/1. Adding Requirements that Lead to Multiway Branching.mp415.35MB
64. 10. Increasing Flexibility by Avoiding Switch Statements/2. Using the Old-fashioned Switch Instruction and an Enum.mp416.57MB
65. 10. Increasing Flexibility by Avoiding Switch Statements/3. Encapsulating Representation in a Separate Class.mp419.73MB
66. 10. Increasing Flexibility by Avoiding Switch Statements/4. Using Encapsulated Representation as the Key.mp417.3MB
67. 10. Increasing Flexibility by Avoiding Switch Statements/5. Turning Multiway Branching into a Dictionary Object.mp414.89MB
68. 10. Increasing Flexibility by Avoiding Switch Statements/6. Substituting the Multiway Branching Object at Runtime.mp434.48MB
69. 10. Increasing Flexibility by Avoiding Switch Statements/7. Summary.mp45.04MB
70. 11. Turning Chained Branching into the Chain of Rule Objects/1. Implementing Classical Chain of If-Then-Elses.mp420.2MB
71. 11. Turning Chained Branching into the Chain of Rule Objects/2. Proposing an Object-oriented Design.mp416.04MB
72. 11. Turning Chained Branching into the Chain of Rule Objects/3. Implementing Concrete Rules.mp422.44MB
73. 11. Turning Chained Branching into the Chain of Rule Objects/4. Simplifying Implementation Through Refactoring.mp420.67MB
74. 11. Turning Chained Branching into the Chain of Rule Objects/5. Combining Primitive Rules into Complex Ones.mp424.28MB
75. 11. Turning Chained Branching into the Chain of Rule Objects/6. Demonstrating the Flexibility of the Chain of Rules.mp425.19MB
76. 11. Turning Chained Branching into the Chain of Rule Objects/7. Summary.mp44.44MB
77. 12. Refactoring to Bind It All Together/1. Introducing an Example.mp48.15MB
78. 12. Refactoring to Bind It All Together/2. Analyzing Initial Implementation.mp411.29MB
79. 12. Refactoring to Bind It All Together/3. Recognizing Infrastructural Code.mp415.71MB
80. 12. Refactoring to Bind It All Together/4. Making Infrastructure Explicit.mp48.02MB
81. 12. Refactoring to Bind It All Together/5. Removing All Infrastructure from Implementation.mp418.69MB
82. 12. Refactoring to Bind It All Together/6. Where to Go with Infrastructural Code.mp419.01MB
83. 12. Refactoring to Bind It All Together/7. Making Profit on Flexibility of Object-oriented Code.mp427.85MB
84. 12. Refactoring to Bind It All Together/8. Summary.mp44.08MB
85. 12. Refactoring to Bind It All Together/9. Course Summary.mp412.44MB