Teach on Udemy

Turn what you know into an opportunity and reach millions around the world.

Learn More

Your cart is empty.

Keep shopping

Software Architecture: Dependency Injection for C# Devs

Name: Software Architecture: Dependency Injection for C# Devs
Rating: 4.0 (411 reviews)

Learn Dependency Injection techniques along with an IoC-framework (DI-Container). Grow Architecture applying DI.

Created byEngineer Spock

Last updated 7/2020

English

What you'll learn

Deeply understand the concepts of Dependency Injection and Inversion of Control
Apply Dependency Inversion Principle (DIP) in practice
Understand the concept of DI-Containers (IoC-Containers)
Build a trivial IoC-Container on your own
Apply existing IoC-Containers (frameworks)
Refactor your code by applying DI coming up with significantly improved Architecture
Write unit tests (this course includes introduction to Unit Testing)
Apply AOP (aspect-oriented programming) techniques

Course content

9 sections • 86 lectures • 5h 18m total length

How to Ask Questions0:22
Introduction to Unit Testing0:11
Download Source Code and Slides0:03
English Subtitles0:06
Join .NET Community of Students0:02

Outline1:35
The outline of the section dedicated to Dependency Inversion Principle (DIP) and Dependency Injection (DI) where you'll learn the main definitions and concepts.
Definition of DIP3:30
Learn what is Dependency Inversion Princple (DIP) in essence.
Dependencies4:49
Learn the definition of a dependency.
Volatile and Stable Dependencies2:53
Learn the difference between volatile dependencies and stable dependencies.
Definitions of IoC and DI3:18
Learn what is "inversion of control" and "dependency injection".
DIP Violation Demo2:47
Look at an example of DIP violation on practice.
Refactoring to a Better Design Applying Dependency Injection8:31
Look at the refactoring process based on Dependency Injection (DI) that leads to a better design of the application.
Dependency Injection Techniques7:09
Learn different Dependency Injection (DI) techniques such as Constructor Injection, Property Injection and Method Injection.
Architectural Implications5:24
Learn about the architectural implications of dependency injection.
Common Smells of DIP Violation2:37
Learn about the common smells of Dependency Inversion Principle (DIP) violation.
Conclusion2:03
A conclusion of the section dedicated to Dependency Inversion Principle (DIP) and Dependency Injection (DI). Recap what you learned.

Outline1:07
Outline of the second section dedicated to DI-Containers (IoC-Containers).
Pure DI and IoC-Containers5:01
Learn what is Pure DI and how it differs from IoC-Containers (DI-Containers).
Building a Simple IoC-Container3:53
Learn how to build your own naive implementation of a DI-Container.
Service Locator Design Pattern2:54
Learn what is Service Locator and how to implement it. What is the difference between a DI-Container and Service Locator?
Demo With an IoC-Container10:21
Conclusion1:17
The conclusion for the section on IoC-Containers (DI-Containers). Recap what you learned.

Outline1:54
The outline of the third section "Dependency Injection - Related Anti-Patterns & Refactorings". Learn what the most common DI-related anti-patterns exist and how to avoid them or how to remove them by applying proper refactorings.
Control Freak7:06
Learn about the dependency injection anti-pattern called "Control Freak".
Hidden Dependencies with Service Locator4:41
Learn about the dependency injection anti-pattern called "Hidden Dependencies" that is caused by wrong use of Service Locator design pattern.
Temporal Coupling and Constructor Injection1:47
Learn about the dependency injection anti-pattern called "Temporal Coupling" and how to avoid it by applying the constructor injection technique.
Constructor Over-Injection4:05
Learn about the dependency injection anti-pattern called "Constructor Over-Injection" and how to avoid it by applying corresponding refactorings.
Ambient Context3:53
Learn the Ambient Context design pattern and how to applyt it to avoid the "Constructor Over-Injection" anti-pattern.
Facade Service2:58
Learn what is Facade Service and how to apply it to avoid constructor over-injection,
Property Injection VS Bastard Injection3:34
Learn about the dependency injection anti-pattern called "Bastard Injection" and how to cure the decease by applying the property injection.
Cyclic Dependencies10:50
Learn what is "cyclic dependencies" and why they are pure evil.
Conclusion2:35
The conclusion on the third section dedicated to DI-related anti-patterns and refactorings.

Outline1:13
The outline of the fourth section dedicated to analysis of a real-world code example where we apply Dependency Injection to achive loosely coupled code.
Application Overview1:24
An overview of an application we're going to work on.
Data Access and Models2:00
Overview of the Data Access Layer.
UI-Side3:18
In this lecture, I'll demonstrate you the UI-side of the sample application.
The Problem of Tight Coupling3:41
In this lecture, you'll learn about the problem of tight coupling that can be fixed by Dependency Injection.
Refactoring Process10:30
In this lecture, you'll learn how to refactor the code base towards loosely-coupled code by applying dependency injection.
Isolating the Bootstrapper4:20
Learn how to isolate the bootstrapper to adhere to the SRP (Single Responsibility Principle).
Consequences1:54
Learn what are the consequences of refactoing we performed by applying dependency injection.
Conclusion1:14
The conclusion on the refactoring of a real-world example by applying dependency injection to achive loosely coupled code.

Outline0:27
The outline of the fifth section dedicated to harnessing the pros of loosely-coupled code achived through Dependency Injection.
Adding New DAL8:58
In this lecture, I'll show you how to add new data access layer in a loosely-coupled code that was achieved by applying dependency injection.
Writing Unit Tests for View Models10:17
In this lecture, you'll see how to write a unit test for a view model in a loosely coupled code achieved by applying dependency injection.
Conclusion0:45
The conclusion on the section dedicated to harnessing the pros of loosely-coupled code that was achieved by applying dependency injection.

Outline1:35
The outline of the sixth section dedicated to DI-Containers (IoC-Containers).
Overview of DI-Containers3:46
Learn what DI-Containers in the world of .NET platforms exist.
Unity DI-Framework10:17
Learn how to build a bootstrapper with a Unity DI-Containe.
Late Binding with Unity5:30
Learn what is late binding and how to implement it with Unity.
Aspect-Oriented Programming (AOP)3:49
Learn what is Aspect-Oriented Programmin or AOP in short.
Demonstration of the Problem of Boilerplate Code4:08
Look at the problem of the boilerplate code that can be solved by AOP.
Implementing AOP by Intercepting5:19
Learn how to apply AOP by using the power of Intercepting feature of Unity.
Interception vs Pure DI vs AOP Tooling2:40
Learn the pros and cons of different approaches to implement AOP.
Autofac and Castle.Windsor DI-Containers4:29
Learn how to build a bootstrapper with Autofac and Castle.Windsor DI-Containers.
Problems Related to DI-Containers1:57
Learn what the problems are related to DI-Containers.
Conclusion0:57
The conclusion on the sixth section dedicated to DI-Containers (IoC-Containers).
BONUS Lecture1:18
Join the mailing list for the biggest discounts on any of my video courses and explore my Patreon page, and leave a review to support the course.

Outline0:58
What is a Unit Test3:09
Explore the purpose and structure of unit tests, definitions of system under test, and the key difference between unit and integration tests, including test doubles for isolation.
Unit Testing Frameworks3:22
Your First Unit Test8:43
Naming Conventions4:34
Explore unit test naming conventions: project and class names, three naming styles, and how use cases, scenarios, and outcomes shape readable tests, with Visual Studio test execution insights.
Running and Debugging Unit Tests5:02
Learn how to use Visual Studio for unit testing: build the solution, run and re-run tests, create playlists to group tests, and debug tests with breakpoints.
Benefits of Unit Tests3:35
Unit tests act as a safety net, verifying correct behavior and catching unintended changes. They boost productivity, enable safer refactoring, and support continuous integration as a core process.
Who Should Write Unit Tests and When2:51
Programmer's Oath3:17
Explore the programmer's oath and its emphasis on responsibility, unit testing and test-driven design, frequent small releases, honest estimates, and continuous improvement in software architecture.
Exercise: Degree Converter1:29
Solution: Degree Converter6:54
Conclusion1:15
Learn how unit tests call a function, verify outcomes, and identify the system under test, using the three-part naming template and Visual Studio's test discovery after builds.

Outline1:01
Install and run a unit testing framework in Visual Studio, write assertions with new unit API, implement setup and teardown, group and ignore tests, run from console, and calculate coverage.
Assert Intro5:29
Examine the assertion model at the heart of unit testing, using constraint-based expressions like all, has, and not to build fluent, expression-tree assertions.
Assert Demo10:27
Explore how unit tests validate a game character class using diverse assertions, covering strings, numeric values, booleans, nulls, collections, type checks, ranges, and exception handling.
Arrange-Act-Assert0:58
Explore the arrange-act-assert pattern in unit testing, showing how to set up the system under test, call one or more methods, and verify behavior with assertions.
Running Tests from the Console1:51
SetUp and TearDown5:09
OneTimeSetUp and OneTimeTearDown2:13
Parameterized Unit Tests3:40
Grouping and Ignoring Unit Tests2:14
Group tests with a category attribute at class or method level to organize the test suite. Use the ignore attribute to skip tests and view ignored tests in test runner.
Code Coverage1:42
Exercise: FizzBuzz1:07
Solution: FizzBuzz5:05
Exercise: Parsing Roman Numerals2:27
Implement a Roman numeral parser that converts numerals to Arabic numbers, handle subtractive notation, and prove the algorithm with unit tests.
Solution: Parsing Roman Numerals9:27
Exercise: Stack0:59
Practice writing unit tests for a simple stack by covering push, pop, and peek methods, testing the public API and preparing for the next lecture with a sample solution.
Solution: Stack9:02
Demonstrate unit testing a stack in C#, covering empty state, count, push and pop behavior, peak results, and exception handling, then discuss test coverage goals.
Conclusion1:25

Requirements

Some experience in C#

Description

Build a solid foundation in software architecture applying Dependency Injection with IoC-Containers

In many of my courses I use techniques of Dependency Injection and each time students write me private messages saying that they don't what it is and thus they don't understand what's going on in the course I teach. This is very unfortunate from the learning perspectives.

Dependency Injection is the set of techniques that allow to supply dependencies to objects. Actually, if you have ever passed dependencies via constructors, then you applied the so-called constructor injection. Dependency Injection (DI) is simple and difficult at the same time. On one hand, DI is comprised of simple techniques and on the other hand, when we need to bring DI to the next level, we need to make things more complicated using the so-called DI or IoC (Inversion of Control) Containers. These are the frameworks which perform dependency injection automatically. You just need to set one up in the application root (an extremely important notion which you'll learn about in the course) and after that, it will resolve all the dependencies it knows about in the runtime.

If you still don't understand what am I talking about, just believe me, you absolutely need to know about Dependency Injection. This course will tremendously improve your understanding of how software architectures emerge. So, this course is "must watch" for anyone who still doesn't understand what is DI and IoC-Containers.

Content and Overview

This course is aimed at all kind of developers. It provides solid theoretical base reinforced by practical material.

The course covers:

Introduction to Inversion of Control:
Dependency Inversion Principle (DIP), Inversion of Control (IoC), Dependency Injection (DI),
Dependencies and their types, Pure DI and IoC-Containers, Service Locator
The Architectural Implications of Dependency Injection
DI-related Anti-Patterns & Refactorings:
Control Freak, Hidden Dependencies, Temporal Coupling,
Constructor Over-Injection and how to avoid it,
Ambient Context, Facade Service, Property Injection vs Bastard Injection, Cyclic Dependencies
Refactoring Example of an existing code base applying Dependency Injection
How to reap the fruits of DI
DI-Containers (IoC-Containers):
Overview, Unity, Late Binding with Unity, Aspect-Oriented Programming (AOP), Interception vs Pure DI vs AOP Tools,
Setting up a bootstrapper with Unity, Autofac and Castle.Windsor
Introduction to Unit Testing

Teaching Approach

No fluff, no ranting, no beating the air. I respect your time. The course material is succinct, yet comprehensive. All the important concepts are covered. Particularly important topics are covered in-depth.

Take this course, and you will be satisfied.

Who this course is for:

Any C# developer who wants to learn about Dependency Injection and IoC-Frameworks

Software Architecture: Dependency Injection for C# Devs

What you'll learn

Explore related topics

Course content

Before taking the Course5 lectures • 1min

Dependency Inversion Principle and Dependency Injection11 lectures • 45min

Introduction to IoC-Containers (or DI-Containers)6 lectures • 25min

Dependency Injection - Related Anti-Patterns & Refactorings10 lectures • 43min

Dependency Injection Real-World Example9 lectures • 30min

Reaping the Fruits of DI4 lectures • 20min

DI-Containers (IoC-Frameworks)12 lectures • 46min

Appendix. Intro to Unit Testing. Getting Started12 lectures • 45min

Appendix. Intro to Unit Testing. NUnit Framework17 lectures • 1hr 4min

Requirements

Description

Who this course is for: