Software Architecture: Meta and SOLID Principles in C#

About Software Architecture: Meta and SOLID Principles in C#

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: 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