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

Free Download S.O.L.I.D Principles And Design Patterns For C# Developers
Published 6/2023
MP4 | Video: h264, 1280×720 | Audio: AAC, 44.1 KHz
Language: English | Size: 4.10 GB | Duration: 8h 46m
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.

Homepage

https://www.udemy.com/course/solid-design-patterns-c-sharp-developers/