Theory to practice ratio: 100% practice
Duration: 3 days
Everyone needs a refresh or a reminder of good coding practices. This training offers a unique take by:
- Being 100% hands-on.
- Showing how to refactor from bad to good code.
- Presenting design patterns in a modern take. They are more than 20 years old by now.
- Including proper behaviors with DI containers and ORM frameworks.
- SOLID is the basis for understanding design patterns SOLID principles are the key to understanding design patterns.
- Design patterns as recipes to testable code
- Factory and Abstract Factory design patterns - basic, but still misunderstood and misused pattern.
- Builder design pattern - how it is different from a state machine and how beneficial it is in tests.
- Strategy design pattern - separating object responsibilities leads to smaller and cleaner classes.
- Object pool - understanding the most basic patterns for IO communication.
- State Machine design pattern - rethinking code habits with OOP principles leads to readable and trivial to test code
- Rules design pattern - moving from nested
ifsto clean, readable and testable code.
- Chain of responsibility design pattern - key pattern to understand most UI frameworks.
- Singleton design pattern - refreshed, and proper usage of one of the most common design patterns. We also measure different implementations with Benchmark.net to remove any performance myths.
- Observable design pattern - a very powerful pattern, especially when used with reactive programming and Reactive Extensions.
- Knowing Your toolset:
- DI containers
- Understanding how a DI container works.
- Defining container responsibilities.
- How to organize registrations.
- Proper lifecycle management.
- Data modeling and ORM
- Understanding how an ORM framework works.
- Modeling hierarchies.
- Modeling value and refernce types.
- Auditing objects with listners.
- DI containers
After the training all attendees get a before and after zip package with all excercises done during the workshop.