Software Architecture: Meta and SOLID Principles in C#

Few Words About Me

A Bit of Advertisment

SOLID Principles

Introduction

1. But what is design?
2. How to define the design of software?
3. Did you notice that almost all the smells are related to bad dependencies management?
4. So, the key to achieving a good architecture is to manage the dependencies well.

SRP - Single Responsibility Principle

1. Outline
2. Problem Statement
3. Classes with too many responsibilities are hard to understand!
4. Demonstration of the Problem
5. Refactoring to a Better Design
6. Remember that inheritance couples the parent and child classes very tight.
7. Everything depends on the requirements of an application.
8. More Example of Violation the SRP
9. Does this method violate SRP?
10. Tip
11. Does this method violate the SRP?
12. Tip
13. Does this method violates the SRP?
14. Related Patterns
15. Conclusion

OCP – OpenClosed Principle

1. Outline
2. Problem Statement
3. Question
4. Why OCP?
5. FYI
6. So, the Principle of Single Choice sounds like this:
7. Demo of the Problem
8. Refactoring to a Better Design
9. OCP-Related Patterns
10. How to choose between them?
11. Rule of thumb
12. Question
13. Common Smells
14. Conclusion

LSP – Liskov Substitution Principle

1. Outline
2. Problem Statement
3. Question
4. FYI
5. Contracts
6. So, what is a contract?
7. Interfaces are not contracts.
8. What constitutes a method’s contract?
9. Important
10. Demo of the Problem
11. FYI
12. Refactoring to a Better Design
13. Question
14. More Examples of LSP Violation
15. Common Smells
16. Here are some tips to conform with LSP:
17. Conclusion

ISP – Interface Segregation Principle

1. Outline
2. Problem Statement
3. Demo of the Problem
4. Refactoring to a Better Design
5. Important
6. Demo of the Problem 2
7. Refactoring to a Better Design 2
8. Common Smells, Fixes and Related Patterns
9. Tip
10. Question
11. FYI
12. Tip
13. Tip
14. Tip
15. Conclusion

DIP – Dependency Inversion Principle

1. Outline
2. Definition of DIP
3. FYI
4. Question
5. Dependencies
6. Volatile and Stable dependencies
7. Question
8. Definitions of IoC and DI
9. DIP violation Demo
10. Refactoring to a Better Design applying Dependency Injection
11. DI Techniques
12. Architectural Implications
13. Question
14. Pure DI and IoC-Containers
15. Building a Simple IoC-Container
16. Demo with IoC-Container
17. Common Smells
18. Conclusion

Metaprinciples and SOLID

1. Outline
2. DRY – Don’t Repeat Yourself
3. The question is
4. FYI
5. KISS – Keep it Simple, Stupid
6. Question
7. Remember, that there are two values of software.
8. YAGNI – You Ain’t Gonna Need It
9. Separation of Concerns
10. CQS Principle
11. Violation of Law of Demeter
12. Principle of Least Astonishment
13. Information Hiding and Encapsulation
14. Question
15. General Principles of Building APIs
16. Question
17. Conclusion

The Interconnection between Metaprinciples and SOLID

1. Outline
2. SOLID vs YAGNI
3. Question
4. OCP vs YAGNI
5. Question
6. SRP and ISP. What’s the Difference?
7. Architecture and Design
8. Question
9. Conclusion