Dependency injection net core console application setup

Question

I am trying to use dependency injection for a.Net Core Console application using the built in DI.

I have 2 following Methods:

    private static void RegisterServices()
    {
        var collection = new ServiceCollection();

        //repositories
        collection.AddScoped<IAccountDataRepository, AccountDataRepository>();
        collection.AddScoped<IClientDataRepository, ClientDataRepository>();
        collection.AddScoped<IAddressDataRepository, AddressDataRepository>();
        collection.AddScoped<IClientAccountDataRepository, ClientAccountDataRepository>();
        //services
        collection.AddScoped<IAccountDataService, AccountDataService>();
        collection.AddScoped<IClientDataService, ClientDataService>();
        collection.AddScoped<IAddressDataService, AddressDataService>();
        collection.AddScoped<IClientAccountDataService, ClientAccountDataService>();

        _serviceProvider = collection.BuildServiceProvider();

    }

    private static void DisposeServices()
    {
        if (_serviceProvider == null)
        {
            return;
        }
        if (_serviceProvider is IDisposable)
        {
            ((IDisposable)_serviceProvider).Dispose();
        }
    }

I can get this to work in the main method by using this:

private static IServiceProvider _serviceProvider;
private static IClientDataRepository _clientDataRepository;



static void Main(string[] args)
{

    RegisterServices();

    _clientDataRepository = _serviceProvider.GetService<IClientDataRepository>();

However I need to inject the repository to the service and the service to main but I can t use the following in the service class:

_clientDataRepository = _serviceProvider.GetService<IClientDataRepository>();

Here is service:

public class ClientDataService : IClientDataService
{
    private readonly ILogger _logger;
    private readonly IClientDataRepository _clientDataRepository;

    public ClientDataService(ILogger logger, IClientDataRepository clientDataRepository)
    {
        _logger = logger;
        _clientDataRepository = clientDataRepository;
    }

If I use

_clientDataRepository = _serviceProvider.GetService<IClientDataRepository>();

will give an error

Answer 1

Just resolve the service and the service provider will inject the repository into the service when building the object graph of the requested object

Based on the provided ClientDataService you would also need to make sure that all dependencies are registered with the service collection.

As it is current shown, ClientDataService also depends on ILogger which does not appear to be registered with the service collection.

services.AddLogging();

The following example uses the originally provided code and refactors to run the main using dependency injection.

public class Program
    private readoonly IClientDataService service;

    public Program(IClientDataService service) {
        this.service = service;
    }

    public void SomeMethod() {
        //...
    }

    //entry
    public static void Main(string[] args) {
        IServiceProvider serviceProvider = RegisterServices();

        Program program = serviceProvider.GetService<Program>();

        program.SomeMethod();

        DisposeServices(serviceProvider);
    }

    //Support
    private static IServiceProvider RegisterServices() {
        var services = new ServiceCollection();

        //repositories
        services.AddScoped<IAccountDataRepository, AccountDataRepository>();
        services.AddScoped<IClientDataRepository, ClientDataRepository>();
        services.AddScoped<IAddressDataRepository, AddressDataRepository>();
        services.AddScoped<IClientAccountDataRepository, ClientAccountDataRepository>();
        //services
        services.AddScoped<IAccountDataService, AccountDataService>();
        services.AddScoped<IClientDataService, ClientDataService>();
        services.AddScoped<IAddressDataService, AddressDataService>();
        services.AddScoped<IClientAccountDataService, ClientAccountDataService>();
        services.AddLogging(); //<-- LOGGING
        //main
        services.AddScoped<Program>(); //<-- NOTE THIS

        return services.BuildServiceProvider();
    }

    private static void DisposeServices(IServiceProvider serviceProvider) {
        if (serviceProvider == null) {
            return;
        }
        if (serviceProvider is IDisposable sp) {
            sp.Dispose();
        }
    }
}