Udemy
    •  
    •  
    •  
    •  
    •  
    •  
    •  
    •  
Subscribe
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Introduction to SOLID Principles
Rating: 4.3 out of 5(245 ratings)
4,217 students

Introduction to SOLID Principles

Introduction to SOLID Principles
Created byZiaullah Khan
Last updated 8/2021
English

What you'll learn

  • Reviewing existing applications for code and architectural improvement
  • Making the safety net of unit test cases before you start modifying application code
  • Identifying and applying design patterns in complex scenario
  • Separating out UI requirements from server side code
  • Writing applications that are easy to understand, change, and maintain

Course content

1 section • 9 lectures • 32m total length

  • Why Refactoring?2:09

    Refactoring improves software design, making maintenance easier, changes safer, and defects easier to locate for teams including new developers throughout requirements analysis, design, development, and testing.

  • What is Refactoring?1:48

    Refactoring restructures software with tools and techniques to improve modifiability and readability while preserving external behavior. It covers renaming, moving features, and making the code solid-compliant, guided by Martin Fowler.

  • Hello World2:34

    Learn how solid principles guide building accessible and maintainable software without changing its behavior, starting with a hello world example to introduce practical concepts.

  • SOLID Principles3:57

    Refactor a hollywood-like app to remove tight coupling and hardcoded messages, implementing the five solid principles: single responsibility, open/closed, substitution, interface segregation, and dependency inversion.

  • Single Responsibility Principle6:15

    The single responsibility principle states that one class should have only one responsibility, so reading and writing are split into two separate classes to keep the design solid and compliant.

  • Dependency Inversion and Interface Segregation Principles2:37

    Explore dependency inversion and interface segregation by refactoring a hello world to use abstractions and separate interfaces, coding against interfaces rather than concrete implementations, and applying client-specific interfaces.

  • Open-Closed and the Liskov-Substitution Principles4:19

    Explore the open-closed and Liskov substitution principles through a hands-on demo that renames components, demonstrates open for extension, and swaps implementations for interchangeable behavior.

  • Single Responsibility Principle - Again3:59
  • Inversion of Control using Unity4:26

Requirements

  • NO Knowledge of SOLID Principles, Design Patterns and Refactoring technique is required
  • Knowledge of Object-Oriented Programming is good to have
  • C#.Net, ASP .NET MVC, and SQL Server

Description

This course starts from the ground up. It starts with a ground-up and talks about the SOLID principles.

The course then picks up the pace and introduces an ASP.NET MVC Application written with the intention of demonstrating the capabilities of the Entity Framework.

Refactoring is making small changes to the application without affecting the observable behavior of the application and at the same time improving the design of the application.

Why Refactoring?

A lot of developers complain that they are familiar with most or all of the techniques of refactoring. They have knowledge of Object-Oriented Programming and Design Patterns as well. But when they work on their projects they hit a roadblock. After some point, it gets very difficult to write clean code. Code that is flexible, extensible, and at the same time is easy to understand, change, and maintain. In complex business applications, it is extremely difficult for most to apply these rules.

When the applications are older and they are supposed to port it to newer platforms it gets more challenging.

This course takes a practical approach. In an existing application that is significantly complex, the course adds test cases which becomes the safety net. The application is then refactored using the SOLID principles and other design patterns which improves the design of the application.

Who this course is for:

  • Developers and Architects who are working on complex application and are curious to improve application flexibility
  • This course is for everyone curios to write enterprise grade state-of-the-art server side applications
  • Taking this course will prepare you to write microservices and cloud native applications

Report abuse