In previous article, we have discussed about how the Serilog file sink can be configured in minimal API project. In this article, we are going to have a look at configuring dependency injection in the same project.
Dependency injection is bit tricky with minimal API. With an
ASP .NET Core Web API which uses controllers, it is very easy to understand as controllers have the constructors and dependencies are resolved via their constructors. But, in case of minimal APIs, there would mostly be not be a constructors involved. Hence, the dependency resolution part is bit different.
In the following sections, we will first have a look at how to register the dependencies and then, we will see how the dependencies can be resolved.
Registering dependencies in minimal API project is exactly similar to what we need to do in API project with controllers. For the sake of this discussion, I have used the default DI container that comes with
ASP .NET Core Web API apps. It has methods – AddTransient, AddScoped and AddSingleton – to register the dependencies.
Let’s take the example of our file
StudentsApi.cs that we have created in previous article. In this file, we have directly injected
UniversityDbContext in the API handlers. We could do that because we have registered the
DbContext dependency by calling
AddDbContext API in
Let’s say, instead of directly injecting
DbContext in API handlers, we want to create a
StudentsRepository. So, let’s go to
MinimalApiDemo.DataAccess and create the repository. The repository should look somewhat similar to code snippet given below.
Now, it’s time to register this dependency. Let’s move to
AppBuilder class. We can register the dependency,
IStudentRepository, by calling
builder.Services.AddTransient – as shown in the code snippet given below.
So, now instead of injecting the
UniversityDbContext, let’s inject the
IStudentRepository in the handlers. The full code snippet is given below.
So, as you can see, registering the dependencies is same as in any other
.NET Core Web API project. Resolving dependency is bit different in case of minimal APIs. Instead of injecting dependencies in the constructor, the dependencies are injected in handler methods.
I hope you find this information helpful. Let me know your thoughts.