Design Patterns And Their Usage With Dependency Injection

Learn key design patterns, how to implement them, and how to use them as clean code in applications.

What you'll learn

By the end of the course, you will understand important design patterns, be able to discover them, classify them, and practically implement them in code.

You are familiar with basic software development principles that pave the way to clean, flexible and maintainable code.

You know how an application is built and at what point design patterns are injected into your code.

The terms Dependency Injection, Composition Root and Object Graph are no longer foreign words to you.

Requirements

Basic knowledge of an object-oriented programming language, e.g. classes, methods

Optional: Visual Studio 2022 to run the examples and exercises

Exercises can also be done within the course using Udemy's built-in IDE without Visual Studio.

Description

Note: The course is also available in German, search for "Entwurfsmuster und ihre Integration mit Dependency Injection"Course to learn frequently used design patternsIn my course you will learn the basics of different, important design patterns of software development. Intentionally, we do not cover all possible design patterns. We limit ourselves to the most commonly used patterns that software developers should know. Other patterns beyond that are beyond the scope and complexity of this course. The course also deals intensively with the practical application of the patterns in connection with Dependency Injection and the SOLID principles, so that Clean Code does not remain just an empty phrase.Design patterns covered:DecoratorCompositeProxyStrategy PatternStrategy ProxyAdapterNull ObjectConcepts covered:SOLID PrinciplesDependency Injection (Constructor Injection)Composition Root (Bootstrapping)Object GraphChaining and reuse of design patternsTarget groupThe course is aimed at beginners with programming knowledge and advanced programmers / developers who want to learn the structure of object-oriented software beyond the pure implementation of functions and algorithms, as well as to further educate themselves in the area of design / architecture. Abstractions and interfaces are briefly introduced in the course, but a prior knowledge of them will facilitate understanding. The course assumes basic knowledge of classes and functions. Developers who already develop and build entire applications, but frequently encounter problems with the maintainability and adaptability of their code, can also benefit from the content. In particular, the knowledge imparted about dependency injection and the composition root can provide new insights here.The examples and exercises are written in C#, a very easy to understand programming language. The concepts covered are cross-language and the code can be easily translated into your own (object-oriented) programming language.Course contentShort theoretical introductions with simple UML diagrams lead - via analogies from the real world - to practical implementations in code. All design patterns are explained using the example "plug and socket". In this way, the function, application and goals of the patterns are explained in an easily understandable way at an abstract level. The focus is always on understanding the patterns as well as the actual implementation. The short theory lessons are accompanied by the simplest UML diagrams.The course is based on an alternation of Video content that explains design patterns on real objects, Presentations that compactly summarize what has been learned,Screencasts showing implementations in real code,Exercises that can be solved independently,Quizzes, for quick self-control of what has been learned, andA final test with over 35 questions covering the entire course.All knowledge about design patterns is useless if you can't use them correctly in an application. Therefore, the course also includes basics on SOLID principles, as well as Dependency Injection and Composition Root, the basis of object-oriented design. With these simple concepts, design patterns can be integrated into applications in such a way that they unleash their true power: adaptive, maintainable and understandable code.Building on this knowledge, we'll go through a real-world example application: the order fulfillment of an e-commerce company. You'll learn about real-world uses of the design patterns, as well as their integration into the application.ExercisesThe entire course is supported by exercises written in C#. You'll get assignments on implementing and building in design patterns. Exercises can be done in two ways. Once they are available directly in the course, via the IDE provided by Udemy including control tests and solutions. Alternatively, the exercises are in the included project folder for the free Visual Studio 2022 Community Edition (or higher).All code, both examples and exercises is provided with unit tests. Even though unit tests are not explicitly discussed in this course, these tests can still help you understand and get you started with Test-First-Development or Test-Driven-Development (TDD). You will see how easy it is to test implementations of the design patterns.

Overview

Section 1: Introduction and Presentation

Lecture 1 Introduction

Lecture 2 Introduction to the course - the Process and Content

Lecture 3 Accompanying Material / IDE & Code

Lecture 4 Unit-Tests

Lecture 5 Exercises

Lecture 6 UML Short Introduction

Section 2: SOLID Principles - The Backbone of Flexible Software Development

Lecture 7 Introduction to SOLID

Lecture 8 Single Responsibility Principle (SRP)

Lecture 9 Open Closed Principle (OCP)

Lecture 10 Liskov Substitution Principle (LSP)

Lecture 11 Interface Segregation Principle (ISP)

Lecture 12 Dependency Inversion Principle (DIP)

Lecture 13 Summary SOLID

Lecture 14 Other Principles, besides SOLID

Section 3: Dependency Injection - The Wiring of Objects

Lecture 15 Introduction

Lecture 16 Theory

Lecture 17 Implementation in Code

Section 4: Composition Root - The entry point to the application

Lecture 18 Introduction

Lecture 19 Theory

Lecture 20 Implementation in Code

Lecture 21 Summary Composition Root and Dependency Injection

Section 5: Introduction to Design Patterns

Lecture 22 Design Patterns and their Characteristics

Lecture 23 Summary Design patterns

Section 6: Design Patterns in the real World

Lecture 24 Explanation of the example - The following lessons are based on this

Lecture 25 Theory

Lecture 26 Implementation in Code

Section 7: Decorator - Add Functionalities to Classes

Lecture 27 Real World Example

Lecture 28 Theory

Lecture 29 Implementation in Code: Power Meter

Lecture 30 Implementation in Code: Night Light

Lecture 31 Exercise 1: Introduction

Lecture 32 Summary

Section 8: Composite - Uniform Treatment of multiple Objects

Lecture 33 Real World Example

Lecture 34 Theory

Lecture 35 Implementation in Code: Multiple Socket

Lecture 36 Summary

Section 9: Proxy - Control creation of and access to Objects

Lecture 37 Real World Example

Lecture 38 Theory

Lecture 39 Implementation in Code: On-Off-Switch

Lecture 40 Implementation in Code: Dimmer

Lecture 41 Implementation in Code: Sound System

Lecture 42 Exercise 2: Introduction

Lecture 43 Summary

Section 10: Strategy Pattern - Abstraction for various Algorithms

Lecture 44 Real World Example

Lecture 45 Theory

Section 11: Strategy Proxy - A practical implementation of the Strategy Pattern

Lecture 46 Real World Example

Lecture 47 Theory

Lecture 48 Implementation in Code: Port Switch

Lecture 49 Summary

Section 12: Adapter - Translate incompatible Interfaces

Lecture 50 Real World Example

Lecture 51 Theory

Lecture 52 Implementation in Code: USB-Adapter

Lecture 53 Exercise 3: Introduction

Lecture 54 Summary

Section 13: Null Object Pattern - Avoiding Null Checks

Lecture 55 Real World Example

Lecture 56 Theory

Lecture 57 Implementation in Code: Socket Protection

Lecture 58 Summary

Section 14: Reuse of Design Patterns

Lecture 59 Real World Example

Lecture 60 Theory

Lecture 61 Implementation in Code: Multiple Socket with Switch

Lecture 62 Exercise 4: Introduction

Lecture 63 Summary

Section 15: Design Patterns applied to practical E-Commerce example

Lecture 64 Example Explanantion - Order Fulfillment in an E-Commerce Software

Lecture 65 Example Explanantion - Implementation in Code

Lecture 66 Payment Logging Decorator - Theory

Lecture 67 Payment Logging Decorator - Implementation in Code

Lecture 68 Notification Null Object - Theory

Lecture 69 Notification Null Object - Implementation in Code

Lecture 70 Notification Composite - Theory

Lecture 71 Notification Composite - Implementation in Code

Lecture 72 Payment Adapter - Theory

Lecture 73 Payment Adapter - Implementation in Code

Lecture 74 Shipping Strategy Proxy - Theory

Lecture 75 Shipping Strategy Proxy - Implementation in Code

Lecture 76 Fulfillment Protection Proxy - Theory

Lecture 77 Fulfillment Protection Proxy - Implementation in Code

Section 16: Final Test

Section 17: Final Part

Lecture 78 FAQs

Lecture 79 Recommended Reading

Lecture 80 Adoption

Software developers with beginner skills who are interested in clean, maintainable and flexible code.,Programmers who want to learn the structured design of an application,Software engineers who want to decouple their application,Software architects who want to understand Dependency Injection and Composition Root,C# developers who want to learn how to implement design patterns in their language.,Software Development Engineers who want to make Clean Code their banner