S.O.L.I.D Principles And Design Patterns For C# Developers

Learn S.O.L.I.D. Principles and Design Patterns to Improve the Quality of your C# Code, with practical exercises.

What you'll learn

Understand and apply S.O.L.I.D principles in software development using C#

Acquire skills in the use of design patterns in C#.

Develop a deep understanding of how S.O.L.I.D principles and design patterns improve the maintainability, scalability, and reusability of code.

Effectively apply S.O.L.I.D principles and design patterns in a C# project from start to finish.

Requirements

Proficiency in C# programming language.

Basic understanding of object-oriented programming (OOP).

Understanding of basic coding principles like variables, control structures, and functions.

Basic knowledge of UML (Unified Modeling Language) for designing.

Description

Welcome to "Mastering SOLID Principles and Classic Design Patterns," a comprehensive course meticulously curated for C# developers. Guided by Microsoft MVP and veteran software developer Hector Perez, this course aims to instill the foundational understanding of SOLID principles and classic design patterns, thereby elevating your coding skills to new heights.SOLID Principles and Classic Design Patterns are key to producing clean, modular, and maintainable code, forming the bedrock of best software development practices. You'll gain a firm understanding of the five SOLID principles — Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. We'll walk you through their applications, elucidating how to leverage these principles to foster code cleanliness and maintainability.This course also provides an in-depth exploration of the 23 classic design patterns propounded by the Gang of Four, segmented into Creational, Structural, and Behavioral patterns. Each pattern is a solution to a unique design issue, enhancing code reusability and fostering software that is comprehensible, scalable, and maintainable.Complementing theoretical learning, this course features extensive coding demonstrations to help cement your understanding of SOLID principles and design patterns. These demos are readily available for download, facilitating hands-on learning at your preferred pace.By the conclusion of this course, you will have mastered the SOLID principles and the Gang of Four's design patterns, empowering you to produce efficient, maintainable, and scalable code. The curriculum covers a wide range of topics, including introductions to SOLID principles and Gang of Four design patterns, and deep dives into Creational, Structural, and Behavioral patterns.To ensure an optimal learning experience, a rudimentary knowledge of software development and object-oriented programming is recommended. Embark on this journey to become a proficient C# developer, adept at modern software development with SOLID principles and Gang of Four design patterns. We're eager to see you in the course!

Overview

Section 1: CQS Software Principle

Lecture 1 Do we really know what encapsulation is?

Lecture 2 Bad code and why to worry about it

Lecture 3 Example of non-empathic code

Lecture 4 What is CQS?

Lecture 5 Queries

Lecture 6 Commands

Lecture 7 Inputs

Lecture 8 Outputs

Lecture 9 Completed Project

Section 2: SOLID Principles - Single Responsability Principle

Lecture 10 What are the SOLID principles?

Lecture 11 Coupling

Lecture 12 Cohesion

Lecture 13 SRP Principle

Lecture 14 Examining the sample project

Lecture 15 Applying the SRP principle

Section 3: SOLID Principles - Open Closed Principle

Lecture 16 What is the Open Closed Principle?

Lecture 17 Implementing the Open Closed Principle

Section 4: SOLID Principles - Liskov's Substitution Principle

Lecture 18 What is the Liskov Substitution Principle?

Lecture 19 Applying the Liskov Substitution Principle

Section 5: SOLID Principles - Interface Segregation Principle

Lecture 20 What is the Interface Segregation Principle?

Lecture 21 Implementing the Interface Segregation Principle

Section 6: SOLID Principles - Dependency Inversion Principle

Lecture 22 What is the Dependency Inversion Principle?

Lecture 23 Implementing the Dependency Inversion Principle

Section 7: Design Patterns - Introduction

Lecture 24 What are design patterns?

Lecture 25 Classification of Design Patterns

Lecture 26 How a design pattern is composed

Section 8: Design Patterns - Factory Method

Lecture 27 Factory Method - Intent

Lecture 28 Factory Method - Motivation

Lecture 29 The Simple Factory Pattern

Lecture 30 Factory Method - Structure

Lecture 31 Factory Method - Implementation

Section 9: Design Patterns - Abstract Factory

Lecture 32 Abstract Factory - Intent

Lecture 33 Abstract Factory - Motivation

Lecture 34 Abstract Factory - Structure

Lecture 35 Abstract Factory - Implementation

Section 10: Design Patterns - Builder

Lecture 36 Builder - Intent

Lecture 37 Builder - Motivation

Lecture 38 Builder - Structure

Lecture 39 Builder - Explanation of initial code

Lecture 40 Builder Implementation

Section 11: Design Patterns - Prototype

Lecture 41 Prototype - Intent

Lecture 42 Prototype - Motivation

Lecture 43 Prototype - Structure

Lecture 44 Prototype - Initial Project Overview

Lecture 45 Prototype - Implementation

Section 12: Design Patterns - Singleton

Lecture 46 Singleton - Intent

Lecture 47 Singleton - Motivation

Lecture 48 Singleton - Structure

Lecture 49 Singleton - Initial Project Overview

Lecture 50 Singleton - Implementation

Lecture 51 Singleton - Thread Safe Implementation

Section 13: Design Patterns - Adapter

Lecture 52 Adapter - Intent

Lecture 53 Adapter - Motivation

Lecture 54 Adapter - Initial Project Overview

Lecture 55 Adapter - Structure

Lecture 56 Adapter - Implementation

Section 14: Design Patterns - Bridge

Lecture 57 Bridge - Intent

Lecture 58 Bridge - Motivation

Lecture 59 Bridge - Initial Project Overview

Lecture 60 Bridge - Structure

Lecture 61 Bridge - Implementation

Section 15: Design Patterns - Composite

Lecture 62 Composite - Intent

Lecture 63 Composite - Motivation

Lecture 64 Composite - Initial Project Overview

Lecture 65 Composite - Using the object type

Lecture 66 Composite - Structure

Lecture 67 Composite - Implementation

Section 16: Design Patterns - Decorator

Lecture 68 Decorator - Intent

Lecture 69 Decorator - Motivation

Lecture 70 Decorator - Initial Project Overview

Lecture 71 Decorator - Structure

Lecture 72 Decorator - Implementation

Section 17: Design Patterns - Facade

Lecture 73 Facade - Intent

Lecture 74 Facade - Motivation

Lecture 75 Facade - Initial Project Overview

Lecture 76 Facade - Structure

Lecture 77 Facade - Implementation

Section 18: Design Patterns - Flyweight

Lecture 78 Flyweight - Intent

Lecture 79 Flyweight - Motivation

Lecture 80 Flyweight - Initial Project Overview

Lecture 81 Flyweight - Structure

Lecture 82 Flyweight- Implementation

Section 19: Design Patterns - Proxy

Lecture 83 Proxy - Intent

Lecture 84 Proxy - Motivation

Lecture 85 Proxy - Initial Project Overview

Lecture 86 Proxy - Structure

Lecture 87 Proxy - Implementation

Section 20: Chain of Responsability

Lecture 88 Chain of Responsability - Intent

Lecture 89 Chain of Responsability - Motivation

Lecture 90 Chain of Responsability - Initial Project Overview

Lecture 91 Chain of Responsability - Structure

Lecture 92 Chain of Responsability - Implementation

Lecture 93 Chain of Responsability - Implementation # 2

Section 21: Design Patterns - Command

Lecture 94 Command - Intent

Lecture 95 Command - Motivation

Lecture 96 Command - Initial Project Overview

Lecture 97 Command - Structure

Lecture 98 Command - Implementation

Lecture 99 Command - Implementation # 2

Section 22: Design Patterns - Iterator

Lecture 100 Iterator - Intent

Lecture 101 Iterator - Motivation

Lecture 102 Iterator - Initial Project Overview

Lecture 103 Iterator - Structure

Lecture 104 Iterator - Implementation

Section 23: Design Patterns - Mediator

Lecture 105 Mediator - Intent

Lecture 106 Mediator - Motivation

Lecture 107 Mediator - Structure

Lecture 108 Mediator - Implementation

Section 24: Design Patterns - Memento

Lecture 109 Memento - Intent

Lecture 110 Memento - Motivation

Lecture 111 Memento - Initial Project Overview

Lecture 112 Memento - Structure

Lecture 113 Memento - Implementation

Section 25: Design Patterns - Observer

Lecture 114 Observer - Intent

Lecture 115 Observer - Motivation

Lecture 116 Observer - Initial Project Overview

Lecture 117 Observer - Structure

Lecture 118 Observer - Implementation

Section 26: Design Patterns - State

Lecture 119 State - Intent

Lecture 120 State - Motivation

Lecture 121 State - Initial Project Overview

Lecture 122 State - Structure

Lecture 123 State - Implementation

Section 27: Design Patterns - Strategy

Lecture 124 Strategy - Intent

Lecture 125 Strategy - Motivation

Lecture 126 Strategy - Initial Project Overview

Lecture 127 Strategy - Structure

Lecture 128 Strategy - Implementation

Section 28: Design Patterns - Template Method

Lecture 129 Template Method - Intent

Lecture 130 Template Method - Motivation

Lecture 131 Template Method - Initial Project Overview

Lecture 132 Template Method - Structure

Lecture 133 Template Method - Implementation

Section 29: Design Patterns - Visitor

Lecture 134 Visitor - Intent

Lecture 135 Visitor - Motivation

Lecture 136 Visitor - Initial Project Overview

Lecture 137 Visitor - Structure

Lecture 138 Visitor - Implementation

Beginner C# developers looking to improve their coding practices.,Experienced C# developers wanting to deepen their understanding of design patterns.,Software engineering students learning C# and interested in mastering best practices.,Tech leads and software architects seeking to enforce better coding standards in their teams.,.NET developers wanting to gain a solid foundation in C# coding principles.,Developers in other languages interested in learning C# and its best practices.