Ever heard of the Law of Demeter? How about the Liskov Substitution Principle? This talk introduces key object-oriented laws and principles currently used in our field and provides guidance for their use when building applications on the .NET platform.
7. domain driven design
All software can be composed of only
four elements:
- Value objects
- Entities
- Services
- Modules
8. separation of concerns
Every class and method should have a
single responsibility.
All its functionality should be narrowly
aligned with that responsibility.
10. theory of one right place
There should be only one right place for a
piece of nontrivial of code,
and one right place to make a likely
maintenance change.
11. unit of work
Define entity families around transactional
boundaries and aggregate root entities.
29. the law of demeter
“Don’t talk to your neighbor’s neighbor!”
An object should only call methods and
properties belonging to:
- Itself
- Any parameters passed in
- Objects it creates
- Child components
30. principle of least resource usage
The minimal amount of computational resources
should be used to solve a particular need.
31. principle of least privilege
Provide the minimal level of access necessary
for consumers to do their job.
Combined with the previous principle…
Classes and methods should be as stateless
and private as possible.
32. the liskov substitution principle
A derived class should be completely and
transparently substitutable for it’s base class.
CommentsAlso know as “Single Responsibility Principle”Cohesion comes from building systems from simple parts that each perform a single duty with no overlap in responsibilitiesAvoid designing classes with more than one responsibility – this leads to the famous “Blob” and “Swiss Army Knife” anti-patternsBusiness Entities should NOT know how to persist themselves
Comments
CommentsSpend the extra 2 minutes to think about the best place for a class or method, it will pay huge dividends later on (see also “Single Responsibility Principle”)Misplaced code leads to the “Lava Flow” and “Cut & Paste” anti-patternsAn elegant design will “feel” rightAlso known as the DRY principle, or Single Point of Truth
Comments
CommentsAllow for hooks into your code, but don’t allow an opening where a derived or external class can alter the fundamental behaviors or algorithms encapsulated by your codeDon’t provide virtual methods for the core behaviors in your classes, only the places where you want to allow extension or changeEvents are (currently) the safest way to adhere to this principle
CommentsIn the words of Steve McConnell, “Assert thyself!”
Comments
CommentsMakes for swappable implementations – analogous to the windows driver model.
CommentsMakes for swappable implementations – analogous to the windows driver model.
CommentsTypical outside sources are xml configuration files.
CommentsTypical outside sources are xml configuration files.
Comments
Comments
Comments
CommentsDon’t write code unless a use case requires itDon’t write code until you need itDon’t build out excess and unnecessary architecture – let it evolve through iterationsChoose the technology to solve the need – not the other way around (avoid the “Golden Hammer” anti-pattern)
CommentsIn software development terms, the simplest solution is usually the best.Strive for simplicity in architecture and design to minimize system entropy and brittlenessWrite the least amount of code necessary to fix a bug or solve the problem
CommentsYour users will only use a small portion of your application most of the time 80% of the execution time in an application is spent executing only 20% of the code Therefore, 80% of your reported bugs will come from the same 20% of codeFocus on simplifying, optimizing, and fortifying that 20%
“Don’t talk to your neighbor’s neighbor” Encapsulation works best when it’s not circumvented
CommentsAvoid allocating more memory or consuming more CPU than necessary to do the job (see also “Occam’s Razor”) Classes and methods should be as static as possible. If a class or method does not need to maintain state (have any member variables), it should be staticBeware of premature optimization
CommentsClasses and members should be as private as possible - “Hide the plumbing”Exposing the internal mechanisms in your library - (accidentally or on purpose) can provide an opening for incorrect usage, breakage or security breachFailure to do so leads to the “Leaky Abstraction” anti-pattern
CommentsDerived classes should never alter the fundamental behavior described by the contract of the base classShould not behave differently (no extra public properties or methods)Should not throw different exceptionsIf this principle is violated, a unit test should uncover it immediatelyPolymorphism works best when not circumventedAlgorithms should not check the type of an object at runtime to determine appropriate behavior