Software Architecture- Meta and SOLID Principles in C#

Software Architecture: Meta and SOLID Principles in C#, available at $79.99, has an average rating of 4.2, with 64 lectures, 1 quizzes, based on 1282 reviews, and has 8624 subscribers.

You will learn about 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 clients lives more enjoyable by applying ISP, making interfaces more granular Determine LSP violations which break clients 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# Im tired to list all the stuff youll be able to do after this course ))) This course is ideal for individuals who are Juniors with a solid C# background or Middle developers who want learn or enhance their knowledge about SOLID principles and Architecture or Seniors who want to have a good reminder of what they already know It is particularly useful for Juniors with a solid C# background or Middle developers who want learn or enhance their knowledge about SOLID principles and Architecture or Seniors who want to have a good reminder of what they already know.

Enroll now: Software Architecture: Meta and SOLID Principles in C#

Summary

Title: Software Architecture: Meta and SOLID Principles in C#

Price: $79.99

Average Rating: 4.2

Number of Lectures: 64

Number of Quizzes: 1

Number of Published Lectures: 64

Number of Published Quizzes: 1

Number of Curriculum Items: 65

Number of Published Curriculum Objects: 65

Original Price: $34.99

Quality Status: approved

Status: Live

What You Will 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 clients lives more enjoyable by applying ISP, making interfaces more granular

Determine LSP violations which break clients 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#

Im tired to list all the stuff youll be able to do after this course )))

Who Should Attend

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

Target Audiences

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

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

Course Curriculum

Chapter 1: Single Responsibility Principle (SRP)

Lecture 1: How to Ask Questions

Lecture 2: Download Source Code and Slides

Lecture 3: Join .NET Community of Students

Lecture 4: Outline

Lecture 5: SOLID Intro

Lecture 6: SRP Definition. Problem Statement

Lecture 7: Demo of the Problem

Lecture 8: Refactoring to a Better Design

Lecture 9: More Examples of SRP Violations

Lecture 10: SRP Related Patterns

Lecture 11: Conclusion

Chapter 2: Open/Closed Principle (OCP)

Lecture 1: Outline

Lecture 2: OCP Definition. Problem Statement

Lecture 3: Demo of the Problem

Lecture 4: Refactoring to a Better Design

Lecture 5: OCP Related Patterns

Lecture 6: Common Smells of OCP Violation

Lecture 7: Conclusion

Chapter 3: Liskov Substitution Principle (LSP)

Lecture 1: Outline

Lecture 2: LSP Definition. Problem Statement

Lecture 3: Contracts

Lecture 4: Demo of the Problem

Lecture 5: Refactoring to a Better Design

Lecture 6: More Examples of LSP Violations

Lecture 7: Common Smells of LSP Violation

Lecture 8: Conclusion

Chapter 4: Interface Segregation Principle (ISP)

Lecture 1: Outline

Lecture 2: ISP Definition. Problem Statement

Lecture 3: Demo of the Problem

Lecture 4: Refactoring to a Better Design

Lecture 5: Demo of the Problem. Example 2

Lecture 6: Refactoring to a Better Design. Example 2

Lecture 7: Common Smells, Fixes and Related Patterns

Lecture 8: Conclusion

Chapter 5: Dependency Inversion Principle (DIP)

Lecture 1: Outline

Lecture 2: DIP Definition. Problem Statement

Lecture 3: Dependencies

Lecture 4: Volatile and Stable Dependencies

Lecture 5: IoC and DI Definitions

Lecture 6: DIP Violation Demo

Lecture 7: Refactoring to a Better Design Applying Dependency Injection (DI)

Lecture 8: DI Techniques

Lecture 9: Architectural Implications

Lecture 10: Pure DI and IoC-Containers

Lecture 11: Building a Simple IoC-Container

Lecture 12: Demo of a Real-World App Built with an IoC-Container

Lecture 13: Common Smells of DIP Violations

Lecture 14: Conclusion

Chapter 6: Metaprinciples and SOLID

Lecture 1: Outline

Lecture 2: DRY – Dont Repeat Yourself

Lecture 3: KISS – Keep it Simple, Stupid

Lecture 4: YAGNI – You Aint Gonna Need It

Lecture 5: SoC – Separation of Concerns

Lecture 6: CQS – Command Query Separation Principle

Lecture 7: Violation of Law of Demeter

Lecture 8: Principle of Least Astonishment

Lecture 9: Encapsulation and Information Hiding

Lecture 10: General Principles of Building APIs

Lecture 11: SOLID VS YAGNI

Lecture 12: OCP VS YAGNI

Lecture 13: SRP and ISP. Whats the Difference?

Lecture 14: Architecture and Design

Lecture 15: Conclusion

Lecture 16: BONUS Lecture

Instructors

Engineer Spock
Software Engineer – 1000+ Reviews, Average Score – 4.5

Rating Distribution

1 stars: 27 votes

2 stars: 36 votes

3 stars: 182 votes

4 stars: 530 votes

5 stars: 507 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

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!