Design Patterns and their Usage with Dependency Injection
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.
- 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.
Note: The course is also available in German, search for "Entwurfsmuster und ihre Integration mit Dependency Injection"
Course to learn frequently used design patterns
In 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:
Dependency Injection (Constructor Injection)
Composition Root (Bootstrapping)
Chaining and reuse of design patterns
The 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.
Short 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, and
A 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.
The 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.
Who this course is for:
- 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
English (German see below):
In 2016, I graduated from the Technical University of Dresden with a degree in electrical engineering with a focus on communications and information technology.
Afterwards, I worked for three years as a software engineer in the automotive industry, especially in the development of media and infotainment systems.
During this time, I was certified as a Certified Professional for Software Architecture (CPSA - Foundation Level) by iSAQB.
In 2019, it was time for new challenges and I moved to the fashion e-commerce sector as a software developer.
Since my youth I have been interested in software development and started early creating first websites and projects. This passion accompanied me through my studies until today.
In 2021 I founded the company Mintuitiv, which inspires children with the fascination of logic through puzzle books and also offers courses around STEM and software development.
2016 habe ich mein Studium der Elektrotechnik im Schwerpunkt Kommmunikations- und Informationstechnik an der TU Dresden als Diplom-Ingenieur abgeschlossen.
Im Anschluss war ich drei Jahre als Software-Ingenieur in der Automotive-Branche tätig, speziell in der Entwicklung von Media- und Infotainment-Systemen.
Während dieser Zeit wurde ich zum Certified Professional for Software Architecture (CPSA - Foundation Level) vom iSAQB zertifiziert.
2019 war es Zeit für neue Herausforderungen und ich wechselte als Software-Entwickler in den Bereich Fashion E-Commerce.
Seit meiner Jugend interessiere ich mich für Software-Entwicklung und begann früh mit dem Erstellen erster Websites und Projekte. Diese Leidenschaft begeleitete mich durch das Studium bis heute.
2021 habe ich das Unternehmen Mintuitiv gegründet, das Kinder durch Rätselhefte für die Faszination der Logik begeistert und darüber hinaus Kurse rund um das Thema MINT und Software-Entwicklung anbietet.