种子简介

种子名称： Making Your C# Code More Object-oriented
文件类型： 视频
文件数目： 85个文件
文件大小： 1.26 GB
收录时间： 2022-7-6 02:42
已经下载： 3次
资源热度： 190
最近下载： 2024-12-2 18:15

下载BT种子文件

下载Torrent文件(.torrent) 立即下载

磁力链接下载

magnet:?xt=urn:btih:e63774d1d6e914176541418745db2766f1c0cf1b&dn=Making Your C# Code More Object-oriented 复制链接到迅雷、QQ旋风进行下载，或者使用百度云离线下载。

喜欢这个种子的人也喜欢

种子包含的文件

Making Your C# Code More Object-oriented.torrent

01. Course Overview/1. Course Overview.mp43.66MB

02. Attaining Extensibility with Object-oriented Code/1. What Makes Code Object-oriented.mp410.18MB

02. Attaining Extensibility with Object-oriented Code/2. What Follows in This Course.mp44.76MB

02. Attaining Extensibility with Object-oriented Code/3. An Example that Lacks Objects.mp410.05MB

02. Attaining Extensibility with Object-oriented Code/4. Putting Objects Where It Doesn’t Seem to Be Possible.mp47.99MB

02. Attaining Extensibility with Object-oriented Code/5. Summary.mp41.35MB

03. Rendering Branching Over Boolean Tests Obsolete/1. Introducing the Problem in Code.mp49.22MB

03. Rendering Branching Over Boolean Tests Obsolete/2. Recognizing the Problem.mp419.93MB

03. Rendering Branching Over Boolean Tests Obsolete/3. Turning Branching into a Function.mp417.52MB

03. Rendering Branching Over Boolean Tests Obsolete/4. Turning Function into a State.mp424.93MB

03. Rendering Branching Over Boolean Tests Obsolete/5. Moving All State-related Code into States.mp431.99MB

03. Rendering Branching Over Boolean Tests Obsolete/6. Assessing Improvement.mp416MB

03. Rendering Branching Over Boolean Tests Obsolete/7. Summary.mp43.49MB

04. Keeping the Focus on Domain Logic with Sequences/1. Understanding the Problem.mp411.62MB

04. Keeping the Focus on Domain Logic with Sequences/2. Outlining the Desired Solution.mp412.56MB

04. Keeping the Focus on Domain Logic with Sequences/3. Aggregating the Sequence.mp420.22MB

04. Keeping the Focus on Domain Logic with Sequences/4. Improving the Readability.mp414.49MB

04. Keeping the Focus on Domain Logic with Sequences/5. Improving Performance of Infrastructural Operations.mp411.43MB

04. Keeping the Focus on Domain Logic with Sequences/6. Summary.mp45.17MB

05. Untangling Structure from Operations on Business Data/1. Identifying the Problem of Selecting an Object.mp48.73MB

05. Untangling Structure from Operations on Business Data/2. Identifying the Problem of Synthesizing an Object.mp422.07MB

05. Untangling Structure from Operations on Business Data/3. Understanding the Problems.mp414.84MB

05. Untangling Structure from Operations on Business Data/4. Treating Collection of Objects as an Object.mp414.33MB

05. Untangling Structure from Operations on Business Data/5. Implementing the Collection of Objects.mp418.37MB

05. Untangling Structure from Operations on Business Data/6. Introducing the Compositional Function Idea.mp429.75MB

05. Untangling Structure from Operations on Business Data/7. Generalized Composition Function.mp434.54MB

05. Untangling Structure from Operations on Business Data/8. Summary.mp43.31MB

06. Turning Algorithms into Strategy Objects/1. Identifying the Problem of a Varying Algorithm.mp414.47MB

06. Turning Algorithms into Strategy Objects/2. Dissecting the Algorithm.mp420.36MB

06. Turning Algorithms into Strategy Objects/3. Identifying the Moving Parts of the Algorithm.mp424.71MB

06. Turning Algorithms into Strategy Objects/4. Analysis of the Template Method with Strategy Object.mp413.58MB

06. Turning Algorithms into Strategy Objects/5. Externalizing Strategy to a Separate Class.mp419.69MB

06. Turning Algorithms into Strategy Objects/6. Implementing a Concrete Strategy Class.mp418.98MB

06. Turning Algorithms into Strategy Objects/7. Summary.mp43.24MB

07. Using Immutable Objects When Possible/1. Causing a Bug That Comes from a Mutable Object.mp417.88MB

07. Using Immutable Objects When Possible/10. Mutable vs. Immutable vs. Value Object.mp418.81MB

07. Using Immutable Objects When Possible/11. Summary.mp44.18MB

07. Using Immutable Objects When Possible/2. Discovering the Aliasing Bug.mp418.09MB

07. Using Immutable Objects When Possible/3. Fixing the Aliasing Bug.mp46.71MB

07. Using Immutable Objects When Possible/4. Understanding Value Objects.mp411.73MB

07. Using Immutable Objects When Possible/5. Implementing Reference Type as a Value Type.mp422.64MB

07. Using Immutable Objects When Possible/6. Consuming the Immutable Class.mp413.77MB

07. Using Immutable Objects When Possible/7. Turning Immutable Objects into Value Objects.mp421.12MB

07. Using Immutable Objects When Possible/8. Supporting Hash Tables.mp415.08MB

07. Using Immutable Objects When Possible/9. Completing the Equality Tests.mp417.79MB

08. Leveraging Special Case Objects to Remove Null Checks/1. Understanding the Problem of Null.mp416.51MB

08. Leveraging Special Case Objects to Remove Null Checks/2. Outlining the Design Without Null References.mp46.22MB

08. Leveraging Special Case Objects to Remove Null Checks/3. How to Never Return Null.mp420.44MB

08. Leveraging Special Case Objects to Remove Null Checks/4. Demonstrating the Power of Null Objects.mp420.47MB

08. Leveraging Special Case Objects to Remove Null Checks/5. Introducing Special Cases.mp412.43MB

08. Leveraging Special Case Objects to Remove Null Checks/6. Turning Boolean Query Methods into Real Operations.mp414.87MB

08. Leveraging Special Case Objects to Remove Null Checks/7. Substituting Objects at Run Time.mp416.87MB

08. Leveraging Special Case Objects to Remove Null Checks/8. Summary.mp43.43MB

09. Turning Optional Calls into Calls on Optional Objects/1. Complicating the Requirements That Lead to Use of Nulls.mp414.03MB

09. Turning Optional Calls into Calls on Optional Objects/2. Identifying the Problem of a Nonexistent Objects.mp417.56MB

09. Turning Optional Calls into Calls on Optional Objects/3. Representing Optional Object as a Collection.mp418.2MB

09. Turning Optional Calls into Calls on Optional Objects/4. Wrapping a Collection into an Option Type.mp420.72MB

09. Turning Optional Calls into Calls on Optional Objects/5. Improving Readability of the Client Code.mp44.8MB

09. Turning Optional Calls into Calls on Optional Objects/6. Adding Pattern Matching to Options.mp411.42MB

09. Turning Optional Calls into Calls on Optional Objects/7. Heavyweight Implementation of Options with Pattern Matching.mp419.32MB

09. Turning Optional Calls into Calls on Optional Objects/8. Demonstrating the Use of Heavyweight Option Type.mp417.36MB

09. Turning Optional Calls into Calls on Optional Objects/9. Summary.mp44.22MB

10. Increasing Flexibility by Avoiding Switch Statements/1. Adding Requirements that Lead to Multiway Branching.mp415.35MB

10. Increasing Flexibility by Avoiding Switch Statements/2. Using the Old-fashioned Switch Instruction and an Enum.mp416.57MB

10. Increasing Flexibility by Avoiding Switch Statements/3. Encapsulating Representation in a Separate Class.mp419.73MB

10. Increasing Flexibility by Avoiding Switch Statements/4. Using Encapsulated Representation as the Key.mp417.3MB

10. Increasing Flexibility by Avoiding Switch Statements/5. Turning Multiway Branching into a Dictionary Object.mp414.89MB

10. Increasing Flexibility by Avoiding Switch Statements/6. Substituting the Multiway Branching Object at Runtime.mp434.48MB

10. Increasing Flexibility by Avoiding Switch Statements/7. Summary.mp45.04MB

11. Turning Chained Branching into the Chain of Rule Objects/1. Implementing Classical Chain of If-Then-Elses.mp420.2MB

11. Turning Chained Branching into the Chain of Rule Objects/2. Proposing an Object-oriented Design.mp416.04MB

11. Turning Chained Branching into the Chain of Rule Objects/3. Implementing Concrete Rules.mp422.44MB

11. Turning Chained Branching into the Chain of Rule Objects/4. Simplifying Implementation Through Refactoring.mp420.67MB

11. Turning Chained Branching into the Chain of Rule Objects/5. Combining Primitive Rules into Complex Ones.mp424.28MB

11. Turning Chained Branching into the Chain of Rule Objects/6. Demonstrating the Flexibility of the Chain of Rules.mp425.19MB

11. Turning Chained Branching into the Chain of Rule Objects/7. Summary.mp44.44MB

12. Refactoring to Bind It All Together/1. Introducing an Example.mp48.15MB

12. Refactoring to Bind It All Together/2. Analyzing Initial Implementation.mp411.29MB

12. Refactoring to Bind It All Together/3. Recognizing Infrastructural Code.mp415.71MB

12. Refactoring to Bind It All Together/4. Making Infrastructure Explicit.mp48.02MB

12. Refactoring to Bind It All Together/5. Removing All Infrastructure from Implementation.mp418.69MB

12. Refactoring to Bind It All Together/6. Where to Go with Infrastructural Code.mp419.01MB

12. Refactoring to Bind It All Together/7. Making Profit on Flexibility of Object-oriented Code.mp427.85MB

12. Refactoring to Bind It All Together/8. Summary.mp44.08MB

12. Refactoring to Bind It All Together/9. Course Summary.mp412.44MB