Software Architecture: Meta and SOLID Principles in C#
4.5 (43 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
419 students enrolled
Wishlisted Wishlist

Please confirm that you want to add Software Architecture: Meta and SOLID Principles in C# to your Wishlist.

Add to Wishlist

Software Architecture: Meta and SOLID Principles in C#

Learn how to develop maintainable software systems applying Meta and SOLID Principles.
4.5 (43 ratings)
Instead of using a simple lifetime average, Udemy calculates a course's star rating by considering a number of different factors such as the number of ratings, the age of ratings, and the likelihood of fraudulent ratings.
419 students enrolled
Created by Elias Fofanov
Last updated 8/2017
English
Current price: $15 Original price: $45 Discount: 67% off
30-Day Money-Back Guarantee
Includes:
  • 4.5 hours on-demand video
  • 3 Articles
  • Full lifetime access
  • Access on mobile and TV
  • Certificate of Completion
What Will I Learn?
  • 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 )))
View Curriculum
Requirements
  • Solid C# Background
  • At least half of a year of experience in a real-world project
Description

Teaching Approach

No fluff, no ranting, no beating the air. I esteem your time. The course material is succinct, yet comprehensive. All important concepts are covered. Particularly important topics are covered in-depth. For absolute beginners, I offer my help on Skype absolutely free, if requested.

Take this course, and you will be satisfied!

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

How long is this course: The course is around 4.5 hours. All are video lectures. You will be able to download all the slides and code samples used in the course.

------------------------------------------------------------

Keywords related to the course:

  • Software Architecture
  • Software Design
  • SOLID Principles
  • SRP, OCP, LSP, ISP, DIP
Who is the target audience?
  • Juniors with a solid C# background
  • Middle developers who want learn or enhance their knowledge about SOLID principles and Architecture
  • Seniors who want to have a good reminder of what they already know
Curriculum For This Course
63 Lectures
04:43:08
+
Single Responsibility Principle (SRP)
10 Lectures 38:42
How to Ask Questions
00:22

Download Source Code and Slides
00:03


Outline
00:38

SRP Definition. Problem Statement
08:07

Demo of the Problem
03:31

Refactoring to a Better Design
05:36

More Examples of SRP Violations
04:21


Conclusion
01:51
+
Open/Closed Principle (OCP)
7 Lectures 31:43
Outline
01:11

OCP Definition. Problem Statement
08:06

Demo of the Problem
02:03

Refactoring to a Better Design
06:15

OCP Related Patterns
10:43

Common Smells of OCP Violation
01:30

Conclusion
01:55
+
Liskov Substitution Principle (LSP)
8 Lectures 30:43
Outline
01:38

LSP Definition. Problem Statement
03:52

Contracts
06:59


Refactoring to a Better Design
02:19

More Examples of LSP Violations
06:10


Conclusion
01:51
+
Interface Segregation Principle (ISP)
8 Lectures 33:55
Outline
01:36

ISP Definition. Problem Statement
04:51

Demo of the Problem
06:50

Refactoring to a Better Design
02:59

Demo of the Problem. Example 2
05:50

Refactoring to a Better Design. Example 2
01:51

Common Smells, Fixes and Related Patterns
07:38

Conclusion
02:20
+
Dependency Inversion Principle (DIP)
14 Lectures 01:00:41
Outline
01:34


Dependencies
04:12

Volatile and Stable Dependencies
02:53

IoC and DI Definitions
03:18

DIP Violation Demo
02:25

Refactoring to a Better Design Applying Dependency Injection (DI)
08:12

DI Techniques
05:54

Architectural Implications
05:24

Pure DI and IoC-Containers
04:31

Building a Simple IoC-Container
03:55

Demo of a Real-World App Built with an IoC-Container
10:27

Common Smells of DIP Violations
02:11

Conclusion
02:15
+
Metaprinciples and SOLID
16 Lectures 01:26:48
Outline
02:17

DRY - Don't Repeat Yourself
09:50

KISS - Keep it Simple, Stupid
07:37

YAGNI - You Ain't Gonna Need It
11:42

SoC - Separation of Concerns
04:28

CQS - Command Query Separation Principle
02:14


Principle of Least Astonishment
03:03

Encapsulation and Information Hiding
05:58

General Principles of Building APIs
14:28

SOLID VS YAGNI
02:58

OCP VS YAGNI
02:48

SRP and ISP. What's the Difference?
01:47

Architecture and Design
04:56

Conclusion
04:23

Final Quiz
15 questions

BONUS Lecture
01:18
About the Instructor
Elias Fofanov
4.3 Average rating
934 Reviews
10,200 Students
9 Courses
Software Engineer

I'm thankful enough for that I love what I do.

I began my career as a postgraduate student participating in Microsoft ImagineCup contest.

I've been working with .NET platform since 2003. I've been professionally architecting and implementing software for nearly 7 years, primarily based on .NET platform. I'm passionate about building rich and powerful applications using modern technologies. I'm a certified specialist in Windows Applications and Service Communication Applications by Microsoft. I'm one of the coordinators of the MSK.NET User Group in Moscow.

"If it's work, we try to do less. If it's art, we try to do more." - Seth Godin.

What I can say is that software is my art.