Making Your C# Code More Object-oriented
برچسب ها:
C Sharp |dotNET Framework |object-oriented |.NET Core |Video |
Pluralsight
Zoran Horvat
2016
7h 4m
English
اغلب برنامه نویسان درک مفهومی از مفاهیم شی گرایی دارند، اما نمی‌توانند آن را به یک کد مناسب شی گرا تبدیل کنند. در دوره ویدیویی Making Your C# Code More Object-oriented موسسه Pluralsight که توسط Zoran Horvat تدریس شده است، شما می‌آموزید که چگونه کد شی گرا مناسبی بنویسید.
در این دوره ابتدا یاد می‌گیرید که چگونه از انشعاب و حلقه جلوگیری کنید. بعد، می‌آموزید که چگونه از عبارات Boolean اجتناب کنید. در پایان نیز خواهید آموخت که چگونه پیاده سازی منطق دامنه را پویا و قابل تنظیم کنید. در پایان این دوره، شما قادر خواهید بود که خطا‌های گذشته خود را بشناسید و سبک کد نویسی صحیح‌تری را پیاده کنید.
فیلم آموزشی «شی گرا‌تر کردن کد‌های سی شارپ خودتان» موسسه پلورال سایت که توسط Zoran Horvat تدریس شده است، دارای زیرنویس انگلیسی است.
Table of Contents:
Course Overview
- Course Overview
Attaining Extensibility with Object-oriented Code
- What Makes Code Object-oriented?
- What Follows in This Course
- An Example that Lacks Objects
- Putting Objects Where It Doesn’t Seem to Be Possible
- Summary
Rendering Branching Over Boolean Tests Obsolete
- Introducing the Problem in Code
- Recognizing the Problem
- Turning Branching into a Function
- Turning Function into a State
- Moving All State-related Code into States
- Assessing Improvement
- Summary
Keeping the Focus on Domain Logic with Sequences
- Understanding the Problem
- Outlining the Desired Solution
- Aggregating the Sequence
- Improving the Readability
- Improving Performance of Infrastructural Operations
- Summary
Untangling Structure from Operations on Business Data
- Identifying the Problem of Selecting an Object
- Identifying the Problem of Synthesizing an Object
- Understanding the Problems
- Treating Collection of Objects as an Object
- Implementing the Collection of Objects
- Introducing the Compositional Function Idea
- Generalized Composition Function
- Summary
Turning Algorithms into Strategy Objects
- Identifying the Problem of a Varying Algorithm
- Dissecting the Algorithm
- Identifying the Moving Parts of the Algorithm
- Analysis of the Template Method with Strategy Object
- Externalizing Strategy to a Separate Class
- Implementing a Concrete Strategy Class
- Summary
Using Immutable Objects When Possible
- Causing a Bug That Comes from a Mutable Object
- Discovering the Aliasing Bug
- Fixing the Aliasing Bug
- Understanding Value Objects
- Implementing Reference Type as a Value Type
- Consuming the Immutable Class
- Turning Immutable Objects into Value Objects
- Supporting Hash Tables
- Completing the Equality Tests
- Mutable vs. Immutable vs. Value Object
- Summary
Leveraging Special Case Objects to Remove Null Checks
- Understanding the Problem of Null
- Outlining the Design Without Null References
- How to Never Return Null
- Demonstrating the Power of Null Objects
- Introducing Special Cases
- Turning Boolean Query Methods into Real Operations
- Substituting Objects at Run Time
- Summary
Turning Optional Calls into Calls on Optional Objects
- Complicating the Requirements That Lead to Use of Nulls
- Identifying the Problem of a Nonexistent Objects
- Representing Optional Object as a Collection
- Wrapping a Collection into an Option Type
- Improving Readability of the Client Code
- Adding Pattern Matching to Options
- Heavyweight Implementation of Options with Pattern Matching
- Demonstrating the Use of Heavyweight Option Type
- Summary
Increasing Flexibility by Avoiding Switch Statements
- Adding Requirements that Lead to Multiway Branching
- Using the Old-fashioned Switch Instruction and an Enum
- Encapsulating Representation in a Separate Class
- Using Encapsulated Representation as the Key
- Turning Multiway Branching into a Dictionary Object
- Substituting the Multiway Branching Object at Runtime
- Summary
Turning Chained Branching into the Chain of Rule Objects
- Implementing Classical Chain of If-Then-Elses
- Proposing an Object-oriented Design
- Implementing Concrete Rules
- Simplifying Implementation Through Refactoring
- Combining Primitive Rules into Complex Ones
- Demonstrating the Flexibility of the Chain of Rules
- Summary
Refactoring to Bind It All Together
- Introducing an Example
- Analyzing Initial Implementation
- Recognizing Infrastructural Code
- Making Infrastructure Explicit
- Removing All Infrastructure from Implementation
- Where to Go with Infrastructural Code?
- Making Profit on Flexibility of Object-oriented Code
- Summary
- Course Summary
می پسندم
به درد نمی خوره
