4.18 out of 5
4.18
319 reviews on Udemy

Software Architecture: Meta and SOLID Principles in C#

Learn how to develop maintainable software systems applying Design Patterns based on Meta and SOLID Principles
Instructor:
Engineer Spock
2,461 students enrolled
English [Auto-generated]
Determine if a class has too many responsibilities
Apply SRP to make classes more granular
Determine the smell of duplication caused by OCP violation
Apply OCP to remove or prevent duplications
Make client's lives more enjoyable by applying ISP, making interfaces more granular
Determine LSP violations which break client's code
Apply LSP to come up with proper inheritance
Apply DIP to develop plugin architecture
Build your own simple IoC-Container
Build clean API in C#
I'm tired to list all the stuff you'll be able to do after this course )))

SOLID is an acronym which stands for SRP, OCP, LSP, ISP and DIP. These five acronyms in their turn stand for:   

  • Single Responsibility Principle   

  • Open/Closed Principle   

  • Liskov Substitution Principle   

  • Interface Segregation Principle   

  • Dependency Inversion Principle

In this course, you’ll learn how to apply meta and SOLID principles so that your application will live a long healthy life. It means you are going to learn how to write code of the high quality: readable, understandable and reliable.   

Improve your knowledge in object-oriented programming   

  • Understand the meta principles on which all the other development principles are based   

  • Understand the symptoms of code defects   

  • Learn the foundations of SOLID principles

  • Learn how to detect the violations of SOLID principles and how to fix the problems

  • Learn how meta principles and SOLID principles are related to each other and how to find the balance between them   

Foundations of writing object-oriented code

Despite the fact that C# is a very rich on features language, it’s very common to see poorly designed and implemented applications in a real world. Language by itself does not guarantee that the architecture of an application will be great. In order to design and build maintainable software, we need to understand the principles of software development. This video course is exactly about how to achieve clean and maintainable software.   

You probably have already heard the following well-known statement: most code sucks. Well, this course is all about how to produce code which doesn’t suck.   

Owning skills of producing a well-designed and well-implemented types is the prerequisite for the other developers to treat you as a decent professional.   

Content and Overview   

This course is aimed at middle and senior developers. Solid experience in C# is required.   

There are plenty of code examples throughout this course so that you will learn both theoretical and practical material.   

Starting with SOLID principles we will go further to the meta-principles. Going through the SOLID principles, you’ll also learn about the related patterns. Then we will get to the problem of contradictions between different principles. You’ll learn about the relationships between SOLID principles and meta principles.   

In general, you’ll learn in this course:   

  • SRP   

  • OCP   

  • LSP   

  • ISP   

  • DIP   

These are the SOLID principles. You’ll learn the background problems that can be solved by particular principle, you’ll see the demonstrations in code, you’ll learn the related patterns to every principle.   

Learning DIP you’ll in addition learn what is Dependency Injection, Inversion of Control, IoC-Containers and what are the architectural implications of DI.   

Here are other topics you’ll learn in the course:   

  • DRY – don’t repeat yourself   

  • KISS – keep it simple stupid   

  • YAGNI – You Ain’t Gonna Need It   

  • SoC – separation of concerns   

  • CQS – command query separation   

  • Law of Demeter   

  • Principle of Least Astonishment   

  • Information Hiding and Encapsulation   

  • API Development Principles   

  • Contradiction between SOLID and YAGNI   

  • Contradiction between OCP and YAGNI   

  • What is Architecture and Design

Teaching Approach

No fluff, no ranting, no beating the air. I respect your time. The course material is succinct, yet comprehensive. All important concepts are covered. Particularly important topics are covered in-depth.

Take this course, and you will be satisfied!

————————————————————

Keywords related to the course:

  • Software Architecture

  • SOLID Principles Tutorial C#

  • SOLID Tutorial C#

  • Software Design

  • SOLID Principles

  • SRP, OCP, LSP, ISP, DIP

Single Responsibility Principle (SRP)

1
How to Ask Questions
2
Download Source Code and Slides
3
Outline
4
SOLID Intro
5
SRP Definition. Problem Statement
6
Demo of the Problem
7
Refactoring to a Better Design
8
More Examples of SRP Violations
9
SRP Related Patterns
10
Conclusion

Open/Closed Principle (OCP)

1
Outline
2
OCP Definition. Problem Statement
3
Demo of the Problem
4
Refactoring to a Better Design
5
OCP Related Patterns
6
Common Smells of OCP Violation
7
Conclusion

Liskov Substitution Principle (LSP)

1
Outline
2
LSP Definition. Problem Statement
3
Contracts
4
Demo of the Problem
5
Refactoring to a Better Design
6
More Examples of LSP Violations
7
Common Smells of LSP Violation
8
Conclusion

Interface Segregation Principle (ISP)

1
Outline
2
ISP Definition. Problem Statement
3
Demo of the Problem
4
Refactoring to a Better Design
5
Demo of the Problem. Example 2
6
Refactoring to a Better Design. Example 2
7
Common Smells, Fixes and Related Patterns
8
Conclusion

Dependency Inversion Principle (DIP)

1
Outline
2
DIP Definition. Problem Statement
3
Dependencies
4
Volatile and Stable Dependencies
5
IoC and DI Definitions
6
DIP Violation Demo
7
Refactoring to a Better Design Applying Dependency Injection (DI)
8
DI Techniques
9
Architectural Implications
10
Pure DI and IoC-Containers
11
Building a Simple IoC-Container
12
Demo of a Real-World App Built with an IoC-Container
13
Common Smells of DIP Violations
14
Conclusion

Metaprinciples and SOLID

1
Outline
2
DRY - Don't Repeat Yourself
3
KISS - Keep it Simple, Stupid
4
YAGNI - You Ain't Gonna Need It
5
SoC - Separation of Concerns
6
CQS - Command Query Separation Principle
7
Violation of Law of Demeter
8
Principle of Least Astonishment
9
Encapsulation and Information Hiding
10
General Principles of Building APIs
11
SOLID VS YAGNI
12
OCP VS YAGNI
13
SRP and ISP. What's the Difference?
14
Architecture and Design
15
Conclusion
16
Final Quiz
17
BONUS Lecture
You can view and review the lecture materials indefinitely, like an on-demand channel.
Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don't have an internet connection, some instructors also let their students download course lectures. That's up to the instructor though, so make sure you get on their good side!
4.2
4.2 out of 5
319 Ratings

Detailed Rating

Stars 5
142
Stars 4
109
Stars 3
52
Stars 2
8
Stars 1
9
a1d3a42da54b056eb4e7ec2cc0c40294
30-Day Money-Back Guarantee

Includes

5 hours on-demand video
2 articles
Full lifetime access
Access on mobile and TV
Certificate of Completion