589689.xyz

Making Your C# Code More Object-oriented

  • 收录时间:2021-07-23 01:39:15
  • 文件大小:1GB
  • 下载次数:1
  • 最近下载:2021-07-23 01:39:15
  • 磁力链接:
立即下载 复制链接

文件列表

  1. 05. Untangling Structure from Operations on Business Data/7. Generalized Composition Function.mp4 35MB
  2. 10. Increasing Flexibility by Avoiding Switch Statements/6. Substituting the Multiway Branching Object at Runtime.mp4 34MB
  3. 03. Rendering Branching Over Boolean Tests Obsolete/5. Moving All State-related Code into States.mp4 32MB
  4. 05. Untangling Structure from Operations on Business Data/6. Introducing the Compositional Function Idea.mp4 30MB
  5. 12. Refactoring to Bind It All Together/7. Making Profit on Flexibility of Object-oriented Code.mp4 28MB
  6. 11. Turning Chained Branching into the Chain of Rule Objects/6. Demonstrating the Flexibility of the Chain of Rules.mp4 25MB
  7. 03. Rendering Branching Over Boolean Tests Obsolete/4. Turning Function into a State.mp4 25MB
  8. 06. Turning Algorithms into Strategy Objects/3. Identifying the Moving Parts of the Algorithm.mp4 25MB
  9. 11. Turning Chained Branching into the Chain of Rule Objects/5. Combining Primitive Rules into Complex Ones.mp4 24MB
  10. 07. Using Immutable Objects When Possible/5. Implementing Reference Type as a Value Type.mp4 23MB
  11. 11. Turning Chained Branching into the Chain of Rule Objects/3. Implementing Concrete Rules.mp4 22MB
  12. 05. Untangling Structure from Operations on Business Data/2. Identifying the Problem of Synthesizing an Object.mp4 22MB
  13. 07. Using Immutable Objects When Possible/7. Turning Immutable Objects into Value Objects.mp4 21MB
  14. 09. Turning Optional Calls into Calls on Optional Objects/4. Wrapping a Collection into an Option Type.mp4 21MB
  15. 11. Turning Chained Branching into the Chain of Rule Objects/4. Simplifying Implementation Through Refactoring.mp4 21MB
  16. 08. Leveraging Special Case Objects to Remove Null Checks/4. Demonstrating the Power of Null Objects.mp4 20MB
  17. 08. Leveraging Special Case Objects to Remove Null Checks/3. How to Never Return Null.mp4 20MB
  18. 06. Turning Algorithms into Strategy Objects/2. Dissecting the Algorithm.mp4 20MB
  19. 04. Keeping the Focus on Domain Logic with Sequences/3. Aggregating the Sequence.mp4 20MB
  20. 11. Turning Chained Branching into the Chain of Rule Objects/1. Implementing Classical Chain of If-Then-Elses.mp4 20MB
  21. 03. Rendering Branching Over Boolean Tests Obsolete/2. Recognizing the Problem.mp4 20MB
  22. 10. Increasing Flexibility by Avoiding Switch Statements/3. Encapsulating Representation in a Separate Class.mp4 20MB
  23. 06. Turning Algorithms into Strategy Objects/5. Externalizing Strategy to a Separate Class.mp4 20MB
  24. 09. Turning Optional Calls into Calls on Optional Objects/7. Heavyweight Implementation of Options with Pattern Matching.mp4 19MB
  25. 12. Refactoring to Bind It All Together/6. Where to Go with Infrastructural Code.mp4 19MB
  26. 06. Turning Algorithms into Strategy Objects/6. Implementing a Concrete Strategy Class.mp4 19MB
  27. 07. Using Immutable Objects When Possible/10. Mutable vs. Immutable vs. Value Object.mp4 19MB
  28. 12. Refactoring to Bind It All Together/5. Removing All Infrastructure from Implementation.mp4 19MB
  29. 05. Untangling Structure from Operations on Business Data/5. Implementing the Collection of Objects.mp4 18MB
  30. 09. Turning Optional Calls into Calls on Optional Objects/3. Representing Optional Object as a Collection.mp4 18MB
  31. 07. Using Immutable Objects When Possible/2. Discovering the Aliasing Bug.mp4 18MB
  32. 07. Using Immutable Objects When Possible/1. Causing a Bug That Comes from a Mutable Object.mp4 18MB
  33. 07. Using Immutable Objects When Possible/9. Completing the Equality Tests.mp4 18MB
  34. 09. Turning Optional Calls into Calls on Optional Objects/2. Identifying the Problem of a Nonexistent Objects.mp4 18MB
  35. 03. Rendering Branching Over Boolean Tests Obsolete/3. Turning Branching into a Function.mp4 18MB
  36. 09. Turning Optional Calls into Calls on Optional Objects/8. Demonstrating the Use of Heavyweight Option Type.mp4 17MB
  37. 10. Increasing Flexibility by Avoiding Switch Statements/4. Using Encapsulated Representation as the Key.mp4 17MB
  38. 08. Leveraging Special Case Objects to Remove Null Checks/7. Substituting Objects at Run Time.mp4 17MB
  39. 10. Increasing Flexibility by Avoiding Switch Statements/2. Using the Old-fashioned Switch Instruction and an Enum.mp4 17MB
  40. 08. Leveraging Special Case Objects to Remove Null Checks/1. Understanding the Problem of Null.mp4 17MB
  41. 11. Turning Chained Branching into the Chain of Rule Objects/2. Proposing an Object-oriented Design.mp4 16MB
  42. 03. Rendering Branching Over Boolean Tests Obsolete/6. Assessing Improvement.mp4 16MB
  43. 12. Refactoring to Bind It All Together/3. Recognizing Infrastructural Code.mp4 16MB
  44. 10. Increasing Flexibility by Avoiding Switch Statements/1. Adding Requirements that Lead to Multiway Branching.mp4 15MB
  45. 07. Using Immutable Objects When Possible/8. Supporting Hash Tables.mp4 15MB
  46. 10. Increasing Flexibility by Avoiding Switch Statements/5. Turning Multiway Branching into a Dictionary Object.mp4 15MB
  47. 08. Leveraging Special Case Objects to Remove Null Checks/6. Turning Boolean Query Methods into Real Operations.mp4 15MB
  48. 05. Untangling Structure from Operations on Business Data/3. Understanding the Problems.mp4 15MB
  49. 04. Keeping the Focus on Domain Logic with Sequences/4. Improving the Readability.mp4 14MB
  50. 06. Turning Algorithms into Strategy Objects/1. Identifying the Problem of a Varying Algorithm.mp4 14MB
  51. 05. Untangling Structure from Operations on Business Data/4. Treating Collection of Objects as an Object.mp4 14MB
  52. 09. Turning Optional Calls into Calls on Optional Objects/1. Complicating the Requirements That Lead to Use of Nulls.mp4 14MB
  53. 07. Using Immutable Objects When Possible/6. Consuming the Immutable Class.mp4 14MB
  54. 06. Turning Algorithms into Strategy Objects/4. Analysis of the Template Method with Strategy Object.mp4 14MB
  55. 04. Keeping the Focus on Domain Logic with Sequences/2. Outlining the Desired Solution.mp4 13MB
  56. 12. Refactoring to Bind It All Together/9. Course Summary.mp4 12MB
  57. 08. Leveraging Special Case Objects to Remove Null Checks/5. Introducing Special Cases.mp4 12MB
  58. 07. Using Immutable Objects When Possible/4. Understanding Value Objects.mp4 12MB
  59. 04. Keeping the Focus on Domain Logic with Sequences/1. Understanding the Problem.mp4 12MB
  60. 04. Keeping the Focus on Domain Logic with Sequences/5. Improving Performance of Infrastructural Operations.mp4 11MB
  61. 09. Turning Optional Calls into Calls on Optional Objects/6. Adding Pattern Matching to Options.mp4 11MB
  62. 12. Refactoring to Bind It All Together/2. Analyzing Initial Implementation.mp4 11MB
  63. 02. Attaining Extensibility with Object-oriented Code/1. What Makes Code Object-oriented.mp4 10MB
  64. 02. Attaining Extensibility with Object-oriented Code/3. An Example that Lacks Objects.mp4 10MB
  65. 03. Rendering Branching Over Boolean Tests Obsolete/1. Introducing the Problem in Code.mp4 9MB
  66. 05. Untangling Structure from Operations on Business Data/1. Identifying the Problem of Selecting an Object.mp4 9MB
  67. 12. Refactoring to Bind It All Together/1. Introducing an Example.mp4 8MB
  68. 12. Refactoring to Bind It All Together/4. Making Infrastructure Explicit.mp4 8MB
  69. 02. Attaining Extensibility with Object-oriented Code/4. Putting Objects Where It Doesn’t Seem to Be Possible.mp4 8MB
  70. 07. Using Immutable Objects When Possible/3. Fixing the Aliasing Bug.mp4 7MB
  71. 08. Leveraging Special Case Objects to Remove Null Checks/2. Outlining the Design Without Null References.mp4 6MB
  72. 04. Keeping the Focus on Domain Logic with Sequences/6. Summary.mp4 5MB
  73. 10. Increasing Flexibility by Avoiding Switch Statements/7. Summary.mp4 5MB
  74. 09. Turning Optional Calls into Calls on Optional Objects/5. Improving Readability of the Client Code.mp4 5MB
  75. 02. Attaining Extensibility with Object-oriented Code/2. What Follows in This Course.mp4 5MB
  76. 11. Turning Chained Branching into the Chain of Rule Objects/7. Summary.mp4 4MB
  77. 09. Turning Optional Calls into Calls on Optional Objects/9. Summary.mp4 4MB
  78. 07. Using Immutable Objects When Possible/11. Summary.mp4 4MB
  79. 12. Refactoring to Bind It All Together/8. Summary.mp4 4MB
  80. 01. Course Overview/1. Course Overview.mp4 4MB
  81. 03. Rendering Branching Over Boolean Tests Obsolete/7. Summary.mp4 3MB
  82. 08. Leveraging Special Case Objects to Remove Null Checks/8. Summary.mp4 3MB
  83. 05. Untangling Structure from Operations on Business Data/8. Summary.mp4 3MB
  84. 06. Turning Algorithms into Strategy Objects/7. Summary.mp4 3MB
  85. Exercise.zip 1MB
  86. 02. Attaining Extensibility with Object-oriented Code/5. Summary.mp4 1MB
  87. 03. Rendering Branching Over Boolean Tests Obsolete/5. Moving All State-related Code into States-en.srt 14KB
  88. 10. Increasing Flexibility by Avoiding Switch Statements/4. Using Encapsulated Representation as the Key-en.srt 13KB
  89. 05. Untangling Structure from Operations on Business Data/7. Generalized Composition Function-en.srt 13KB
  90. 12. Refactoring to Bind It All Together/7. Making Profit on Flexibility of Object-oriented Code-en.srt 13KB
  91. 05. Untangling Structure from Operations on Business Data/6. Introducing the Compositional Function Idea-en.srt 13KB
  92. 10. Increasing Flexibility by Avoiding Switch Statements/6. Substituting the Multiway Branching Object at Runtime-en.srt 12KB
  93. 05. Untangling Structure from Operations on Business Data/2. Identifying the Problem of Synthesizing an Object-en.srt 12KB
  94. 11. Turning Chained Branching into the Chain of Rule Objects/6. Demonstrating the Flexibility of the Chain of Rules-en.srt 12KB
  95. 03. Rendering Branching Over Boolean Tests Obsolete/4. Turning Function into a State-en.srt 11KB
  96. 02. Attaining Extensibility with Object-oriented Code/1. What Makes Code Object-oriented-en.srt 11KB
  97. 08. Leveraging Special Case Objects to Remove Null Checks/3. How to Never Return Null-en.srt 11KB
  98. 09. Turning Optional Calls into Calls on Optional Objects/7. Heavyweight Implementation of Options with Pattern Matching-en.srt 11KB
  99. 07. Using Immutable Objects When Possible/5. Implementing Reference Type as a Value Type-en.srt 11KB
  100. 06. Turning Algorithms into Strategy Objects/3. Identifying the Moving Parts of the Algorithm-en.srt 10KB
  101. 12. Refactoring to Bind It All Together/6. Where to Go with Infrastructural Code-en.srt 10KB
  102. 07. Using Immutable Objects When Possible/7. Turning Immutable Objects into Value Objects-en.srt 10KB
  103. 11. Turning Chained Branching into the Chain of Rule Objects/5. Combining Primitive Rules into Complex Ones-en.srt 10KB
  104. 07. Using Immutable Objects When Possible/10. Mutable vs. Immutable vs. Value Object-en.srt 10KB
  105. 09. Turning Optional Calls into Calls on Optional Objects/2. Identifying the Problem of a Nonexistent Objects-en.srt 10KB
  106. 08. Leveraging Special Case Objects to Remove Null Checks/4. Demonstrating the Power of Null Objects-en.srt 10KB
  107. 11. Turning Chained Branching into the Chain of Rule Objects/3. Implementing Concrete Rules-en.srt 10KB
  108. 09. Turning Optional Calls into Calls on Optional Objects/4. Wrapping a Collection into an Option Type-en.srt 10KB
  109. 04. Keeping the Focus on Domain Logic with Sequences/3. Aggregating the Sequence-en.srt 9KB
  110. 07. Using Immutable Objects When Possible/2. Discovering the Aliasing Bug-en.srt 9KB
  111. 12. Refactoring to Bind It All Together/5. Removing All Infrastructure from Implementation-en.srt 9KB
  112. 10. Increasing Flexibility by Avoiding Switch Statements/1. Adding Requirements that Lead to Multiway Branching-en.srt 9KB
  113. 12. Refactoring to Bind It All Together/9. Course Summary-en.srt 9KB
  114. 07. Using Immutable Objects When Possible/1. Causing a Bug That Comes from a Mutable Object-en.srt 9KB
  115. 03. Rendering Branching Over Boolean Tests Obsolete/3. Turning Branching into a Function-en.srt 9KB
  116. 09. Turning Optional Calls into Calls on Optional Objects/8. Demonstrating the Use of Heavyweight Option Type-en.srt 9KB
  117. 11. Turning Chained Branching into the Chain of Rule Objects/1. Implementing Classical Chain of If-Then-Elses-en.srt 9KB
  118. 06. Turning Algorithms into Strategy Objects/6. Implementing a Concrete Strategy Class-en.srt 9KB
  119. 08. Leveraging Special Case Objects to Remove Null Checks/1. Understanding the Problem of Null-en.srt 9KB
  120. 03. Rendering Branching Over Boolean Tests Obsolete/2. Recognizing the Problem-en.srt 9KB
  121. 10. Increasing Flexibility by Avoiding Switch Statements/3. Encapsulating Representation in a Separate Class-en.srt 8KB
  122. 05. Untangling Structure from Operations on Business Data/5. Implementing the Collection of Objects-en.srt 8KB
  123. 06. Turning Algorithms into Strategy Objects/2. Dissecting the Algorithm-en.srt 8KB
  124. 09. Turning Optional Calls into Calls on Optional Objects/3. Representing Optional Object as a Collection-en.srt 8KB
  125. 12. Refactoring to Bind It All Together/3. Recognizing Infrastructural Code-en.srt 8KB
  126. 10. Increasing Flexibility by Avoiding Switch Statements/2. Using the Old-fashioned Switch Instruction and an Enum-en.srt 8KB
  127. 08. Leveraging Special Case Objects to Remove Null Checks/6. Turning Boolean Query Methods into Real Operations-en.srt 8KB
  128. 07. Using Immutable Objects When Possible/8. Supporting Hash Tables-en.srt 8KB
  129. 06. Turning Algorithms into Strategy Objects/1. Identifying the Problem of a Varying Algorithm-en.srt 8KB
  130. 11. Turning Chained Branching into the Chain of Rule Objects/4. Simplifying Implementation Through Refactoring-en.srt 8KB
  131. 06. Turning Algorithms into Strategy Objects/5. Externalizing Strategy to a Separate Class-en.srt 8KB
  132. 03. Rendering Branching Over Boolean Tests Obsolete/6. Assessing Improvement-en.srt 7KB
  133. 05. Untangling Structure from Operations on Business Data/4. Treating Collection of Objects as an Object-en.srt 7KB
  134. 04. Keeping the Focus on Domain Logic with Sequences/4. Improving the Readability-en.srt 7KB
  135. 04. Keeping the Focus on Domain Logic with Sequences/1. Understanding the Problem-en.srt 7KB
  136. 08. Leveraging Special Case Objects to Remove Null Checks/7. Substituting Objects at Run Time-en.srt 7KB
  137. 12. Refactoring to Bind It All Together/2. Analyzing Initial Implementation-en.srt 7KB
  138. 09. Turning Optional Calls into Calls on Optional Objects/1. Complicating the Requirements That Lead to Use of Nulls-en.srt 6KB
  139. 11. Turning Chained Branching into the Chain of Rule Objects/2. Proposing an Object-oriented Design-en.srt 6KB
  140. 02. Attaining Extensibility with Object-oriented Code/3. An Example that Lacks Objects-en.srt 6KB
  141. 04. Keeping the Focus on Domain Logic with Sequences/2. Outlining the Desired Solution-en.srt 6KB
  142. 04. Keeping the Focus on Domain Logic with Sequences/5. Improving Performance of Infrastructural Operations-en.srt 6KB
  143. 12. Refactoring to Bind It All Together/1. Introducing an Example-en.srt 6KB
  144. 05. Untangling Structure from Operations on Business Data/3. Understanding the Problems-en.srt 6KB
  145. 07. Using Immutable Objects When Possible/9. Completing the Equality Tests-en.srt 6KB
  146. 07. Using Immutable Objects When Possible/6. Consuming the Immutable Class-en.srt 6KB
  147. 10. Increasing Flexibility by Avoiding Switch Statements/5. Turning Multiway Branching into a Dictionary Object-en.srt 6KB
  148. 08. Leveraging Special Case Objects to Remove Null Checks/5. Introducing Special Cases-en.srt 6KB
  149. 03. Rendering Branching Over Boolean Tests Obsolete/1. Introducing the Problem in Code-en.srt 6KB
  150. 07. Using Immutable Objects When Possible/4. Understanding Value Objects-en.srt 6KB
  151. 09. Turning Optional Calls into Calls on Optional Objects/6. Adding Pattern Matching to Options-en.srt 5KB
  152. 02. Attaining Extensibility with Object-oriented Code/4. Putting Objects Where It Doesn’t Seem to Be Possible-en.srt 5KB
  153. 05. Untangling Structure from Operations on Business Data/1. Identifying the Problem of Selecting an Object-en.srt 4KB
  154. 06. Turning Algorithms into Strategy Objects/4. Analysis of the Template Method with Strategy Object-en.srt 4KB
  155. 12. Refactoring to Bind It All Together/4. Making Infrastructure Explicit-en.srt 4KB
  156. 02. Attaining Extensibility with Object-oriented Code/2. What Follows in This Course-en.srt 4KB
  157. 10. Increasing Flexibility by Avoiding Switch Statements/7. Summary-en.srt 3KB
  158. 08. Leveraging Special Case Objects to Remove Null Checks/2. Outlining the Design Without Null References-en.srt 3KB
  159. 11. Turning Chained Branching into the Chain of Rule Objects/7. Summary-en.srt 3KB
  160. 07. Using Immutable Objects When Possible/3. Fixing the Aliasing Bug-en.srt 3KB
  161. 04. Keeping the Focus on Domain Logic with Sequences/6. Summary-en.srt 3KB
  162. 09. Turning Optional Calls into Calls on Optional Objects/9. Summary-en.srt 3KB
  163. 12. Refactoring to Bind It All Together/8. Summary-en.srt 3KB
  164. 06. Turning Algorithms into Strategy Objects/7. Summary-en.srt 3KB
  165. 07. Using Immutable Objects When Possible/11. Summary-en.srt 3KB
  166. 08. Leveraging Special Case Objects to Remove Null Checks/8. Summary-en.srt 2KB
  167. 01. Course Overview/1. Course Overview-en.srt 2KB
  168. 05. Untangling Structure from Operations on Business Data/8. Summary-en.srt 2KB
  169. 03. Rendering Branching Over Boolean Tests Obsolete/7. Summary-en.srt 2KB
  170. 09. Turning Optional Calls into Calls on Optional Objects/5. Improving Readability of the Client Code-en.srt 2KB
  171. 02. Attaining Extensibility with Object-oriented Code/5. Summary-en.srt 1KB