Simple Dependency Injection in .Net 6.0 Web API
Aha! There is always something intimidating about Dependency Injection. I distinctly remember a couple of years ago, telling a .Net recruiter for a contract project, that,
“I had no idea what DI is”
He immediately stopped talking to me. It’s just one of those moments.
It was true, to an extent. It’s one of those things that you have been doing for years, but, you never knew you were doing it.
Like how you unconsciously woo women in college and accidentally end up with a girlfriend.
Or, when you watch so many English movies since childhood, you are accidentally making yourself an excellent speaker of English, without being aware of it.
Anyway, that’s neither here nor there. Let’s get back to, DI.
As always, the code is available here.
CSharpForStudents/WebApiDotNet6/WebAPIWithDependencyInjection at main ·…
Dependency Injection or DI, is one of those things that are essential, but also, mostly confusing. I have put together…
DI gets its name from the final, 5th, enter in SOLID principles. The 5th entry of SOLID says the following.
- High-level modules should not import anything from low-level modules. Both should depend on abstractions (e.g., interfaces).
- Abstractions should not depend on details. Details (concrete implementations) should depend on abstractions.
If you are more curious about SOLID, I recently, wrote about it.
SOLID Principles in C# .Net 6.0 Using Batman As Example
Criminals are a superstitious cowardly lot. That is why, I am going to use SOLID principles in C # and .NET Core to…
Step One — Interface and Implementations
Right then. First up, you want to create an interface and and it’s implementation.
You will notice that I have two implementations. That is on purpose. The whole point of using interfaces is to gain the flexibility of being able to change implementations to prove the decoupling facility provided by DI.
Don’t forget to do some Unit Testing in an xUnit project, whilst you are at it.
Step Two — Inject It
Now, the next step is to inject your interface, along with the implementation. This should happen when your app builds.
This is .Net 6. So, we do this in Program.cs. I am using Scoped way of injecting. There are other ways to inject, which are beyond my knowledge level.
Hopefully, you will read the comments.
Essentially, I, the developer, the coder, and also you, can ‘switch’ between the two implementations.
This way, you use the implementation you want, and the code, is completely unaware of it, hence, decoupling itself from the implementations, current, past and future.
Step Three — The Constructor! Don’t Forget This
The key step.
Note the assignment that happens in the constructor. Without that, DI would fail.
Of course, this is the most simplest case of doing DI. It may not even be the most efficient way of doing it.
But, it works. Hope it helps you.