Solid Principles (2022) for Software Architecture & Design

Solid Principles (2022) for Software Architecture & Design

Solid Principles (2022) for Software Architecture & Design

Master SOLID principles from scratch: Learn how to implement SOLID Principles in REAL LIFE IT project step by step

Language: english

Note: 4.7/5 (23 notes) 2,565 students

Instructor(s): Yogesh Dahake

Last update: 2022-08-12

What you’ll learn

  • Solid principle of OOP object oriented programming for software design and architecture
  • Identify Bad design in the software’s code with Solid Principles knowledge
  • Implement Software Practices using Solid Principles
  • Solid design principles implementation in C#
  • Learn Single responsibility principle SRP
  • Learn Open Closed Principle OCP
  • Learn Liskov substitution principle LSP
  • Learn Interface segregation principle ISP
  • Learn Dependency inversion principle DIP
  • Learn Inversion of Control IOC
  • Learn Dependency Injection DI
  • Commonly used Software design Principles like DRY ,KISS ,GRASP, single source of truth etc



  • Basic knowledge of C# or java or any object oriented programming languages



Solid Principles of OOP Software Design & Architecture | Solid Principles of OOP for Software Architecture & Design

In this course we are going to learn the SOLID Principles of Object Oriented Programming OOP  Software design and architecture, where we will first try to understand :

SOLID Principle was first formulated and motioned by Robert martin in this book  Agile Software Development, Principles, Patterns, and Practices .


What are SOLID Principle S.O.L.I.D

How SOLID principle works in object oriented programming language like  C# and Java with examples

why are solid principles important

How to apply use implement  SOLID principle in real life project and examples.

how to design clean code  using SOLID

Coding of solid principle.

We will also cover all the interview questions getting asked on the SOLID principle

TOPICS covered :

Single responsibility Principle  SRP 

What is single responsibility principle SRP  in object oriented programming language like C# .net and Java with examples.

Why single responsibility principle SRP  are important

Why to use , need of  single responsibility principle SRP 

How to use  implement single responsibility principle SRP 

Open Closed Principle OCP

What are Open Closed Principle OCP  in object oriented programming language like C# .net and Java with examples.

Why Open Closed Principle OCP  are important

Why to use , need of  Open Closed Principle OCP

How to use  implement Open Closed Principle OCP 

Liskov Substitution Principle LSP

What is LisKov Substitution Principle LSP  in object oriented programming language like C# .net and Java with examples.

Why LisKov Substitution Principle LSP   are important

Why to use , need of  LisKov Substitution Principle LSP 

How to use implement LisKov Substitution Principle LSP 

Interface Segregation Principle ISP

What is Interface Segregation Principle ISP  in object oriented programming language like C# .net and Java with examples.

Why Interface Segregation Principle ISP   are important

Why to use , need of  Interface Segregation Principle ISP

How to use implement Interface Segregation Principle ISP

Dependency Inversion Principle DIP 

What is Dependency Inversion Principle DIP  in object oriented programming language like C# .net and Java with examples.

Why Dependency Inversion Principle DIP  are important

Why to use , need of  Dependency Inversion Principle DIP

How to use implement Dependency Inversion Principle DIP.

Dependency Injection DI

What is Dependency Injection DI

To use and implement Dependency Injection.

Dependency injection using DI IOC container like unity container 

Inversion of Control IOC

what is Inversion of control.

How to use and implement  inversion of control

Difference between Dependency Injection and inversion of control  DI vs IOC

Difference between Dependency Inversion Principle DIP vs Dependency Injection DI  vs inversion of control IOC

Along with above SOLID principle ,we  are also going to see the other most commonly used principles in software engineering/ Information Technology / Computer Science field and  those are :

DRY Do Not Repeat Yourself  principle

KISS Principle  Keep it simple Stupid

GRASP ( General Responsibility Assignment Software Patterns ) to some extent in that we will understand Information Expert

Yagni  You ain’t gonna need it.

Opportunity Cost Principle

Big Design Up Front

Rough Design Up Front

Single Source of Truth

Principle of Least Astonishment

All these principle we are going to learn from scratch and learn in the real time project case study example ,we will develop the real life project called Employee Management Portal and we will understand each principle in great detail during coding this Case study.

This case study will help you to develop the design thinking. Our main goal of this case study to make you understand the SOLID principle ,this Case study we will code in oop object oriented programming language like C# ,if you are not aware of C# then also fine ,because we are going to use the concepts which are very common in all programming language, if you know JAVA , JAVASCRIPT , ANGULAR ,REACT , TYPESCRIPT,SWIFT ,PYTHON  then also you can easily follow this course.


Who this course is for

  • Software Developers
  • People who are starting career in IT industry
  • People who are involved in Design and architecting softwares
  • Information Technology Engineer
  • Computer Science Engineer


Course content

  • Introduction
    • Introduction to Solid Principle Course
    • Why this Course & Why you should take this Course | Solid Principle ?
    • What is SOLID Principles
    • Design Smells | Signs of bad design
  • Case Study
    • Solid Principle Case Study Project Overview
    • Case Study Code Setup for Learning Solid Principles
  • Single Responsibility Principle SRP | SOLID principles
    • Single Responsibility Principle SRP | SOLID principles
    • Define Single Responsibility or Single Reason to change
    • Case Study Changes for Defining Responsibility
    • Information Expert Principle-GRASP
    • Decomposition
    • Cohesion
    • Coupling
    • SRP Final Checklist for Implementation
    • SRP Quiz
  • Open Closed Principle OCP | SOLID principles
    • Open Closed Principle OCP
    • OCP Checklist | Open close principle checklist
    • OCP quiz
  • Liskov Substitution Principle LSP | SOLID principles
    • Liskov Substitution Principle LSP
    • LSP in Real Life
    • LSP Checklist
    • LSP Quiz
  • Interface Segregation Principle ISP | SOLID principles
    • Interfaces and Abstraction Concepts
    • Implement Abstraction using Interfaces Part-2
    • Interface Segregation Principle ISP
    • ISP Checklist for implementation
    • ISP Quiz
  • Dependency Inversion Principle IOC | SOLID principles
    • Dependency Inversion Principle DIP
    • Dependency Injection DI
    • Inversion of Control IOC
    • IOC-Case Study Changes
    • DIP Implementation Checklist
    • DIP Quiz
  • Conclusion of SOLID principles Course
    • Summary of Solid Principles
    • Interview Questions Solid Principle
    • Conclusion
  • Common Design Principles of software Engineering
    • DRY Principle
    • KISS Keep it Simple Stupid Principle
    • YAGNI – You ain’t gonna need it
    • Opportunity Cost Principle
    • Occam’s Razor Principle
    • Principle Of Least Astonishment
    • Avoid Premature Optimization
    • Rough Design Up Front – RDUF


Solid Principles (2022) for Software Architecture & DesignSolid Principles (2022) for Software Architecture & Design

Time remaining or 460 enrolls left


Don’t miss any coupons by joining our Telegram group 

Udemy Coupon Code 100% off | Udemy Free Course | Udemy offer | Course with certificate