Software design and clean code cheat sheet (C#)

1. 1Object-oriented programming properlyClasses, objects and the four ideas behind them, used to protect rules and hide change rather than to build deep family trees. Composition over inheritance starts here.8 concepts

   1. 1Class and objectA class is a blueprint that bundles data (fields) with the behaviour that works on it (methods).
   2. 2EncapsulationHiding an object's internal state behind a small public interface, so outside code can only change it through methods that keep its rules (invariants) true.
   3. 3AbstractionShowing callers what something does and hiding how it does it.
   4. 4InheritanceA subclass takes on the fields and methods of a parent class and can add to or override them.
   5. 5PolymorphismOne call working on many types: code asks any Shape for its area, and each type answers in its own way.
   6. 6Interfaces and abstract classesAn interface lists methods a type promises to provide, with no state.
   7. 7Composition over inheritanceBuilding a class by holding other objects and delegating to them (has-a) rather than by extending a parent (is-a).
   8. 8Value objects and immutabilityA value object is defined by its values, not an identity: two Money(10, "USD") objects are equal.

   8 in this chapterOpen this chapter
2. 2SOLID principlesFive principles for classes that are easy to extend and test, each with the smell it prevents. Learn them as questions to ask of a design, not as rules to recite.7 concepts

   1. 1Single responsibility principle (SRP)A class should have one reason to change, meaning it answers to one group of people or one kind of decision.
   2. 2Open/closed principle (OCP)Code should be open for extension and closed for modification: you add behaviour by adding new code, such as a new class, rather than editing working code.
   3. 3Liskov substitution principle (LSP)A subtype must work anywhere its parent type is expected without surprising the caller: it may not demand more, promise less or throw where the parent would…
   4. 4Interface segregation principle (ISP)Clients should not be forced to depend on methods they do not use.
   5. 5Dependency inversion principle (DIP)High-level policy should not depend on low-level details; both should depend on an abstraction.
   6. 6Dependency injectionPassing an object the things it needs, usually through its constructor, instead of letting it create or look them up itself.
   7. 7DRY, KISS and YAGNIDRY: every piece of knowledge has one home.

   7 in this chapterOpen this chapter
3. Clean code: names, functions and errorsThe small decisions made hundreds of times a day: what to call things, how big a function should be, when to comment, and how to fail loudly and clearly.7 conceptsOpens with credits
4. Creational patternsThe five Gang of Four patterns about how objects get made: one shared instance, a subclass choosing the type, families of related objects, step-by-step construction and cloning.5 conceptsOpens with credits
5. Structural patternsThe seven Gang of Four patterns about how objects fit together: translating interfaces, splitting two dimensions, trees, wrappers, simple front doors, shared state and stand-ins.7 conceptsOpens with credits
6. Behavioural patternsThe eleven Gang of Four patterns about how objects share work and talk to each other: passing requests along, packaging actions, swapping algorithms, reacting to events and walking structures.11 conceptsOpens with credits
7. UML and class diagrams you actually needThe small part of UML that working engineers sketch: class boxes, visibility, the five relationship arrows, multiplicity and a sequence diagram. Enough to explain a design on a whiteboard or in a pull request.7 conceptsOpens with credits
8. Refactoring and code smellsChanging the structure of code without changing what it does, in small safe steps behind tests. Smells tell you where to look; named refactorings tell you what to do.9 conceptsOpens with credits
9. Designing small systems end to endLow level design: turning a short problem statement into classes, relationships and working code. A repeatable method, then the classic practice problems and what each one teaches.7 conceptsOpens with credits
10. Code review: giving and taking itReviews are where design skill is taught and tested day to day. What reviewers look for, how to write comments people act on, and how to receive them without taking them personally.5 conceptsOpens with credits
11. 11Glossary, A to ZEvery concept in the sheet and the smaller terms it uses, in one list.124 terms

OOP, SOLID, design patterns, refactoring.