Making Your C# Code More Object-oriented

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