using System;

using System.Collections.Generic;

using System.Linq;

using Microsoft.Extensions.DependencyInjection;

public class Program

{

    public static void Main()

    {

        ServiceCollection services = new ServiceCollection();

        //Register the services with the ServiceProvider

        ServiceResolver.Register<ServiceA>();

        ServiceResolver.Register<ServiceB>();

​

        //Register everything else like normal

        services.AddSingleton<IDependencyB, DependencyB>();

        services.AddSingleton<IServiceResolver, ServiceResolver>();

        //Testing code to show everything works like you'd expect

        IServiceProvider provider = services.BuildServiceProvider();

        IServiceResolver resolver = provider.GetRequiredService<IServiceResolver>();

        //Ensure we can get the services

        foreach(IService service in resolver.GetServices())

        {

            service.Test();

        }

        //Ensure we can't get IService, this will throw an exception

        provider.GetRequiredService<IService>();

    }

}

​

public class ServiceResolver : IServiceResolver

{

    public static void Register<TService>() where TService : IService

    {

        ServiceTypes.Add(typeof(TService));

    }

    public ServiceResolver(IServiceProvider serviceProvider)

    {

        _serviceProvider = serviceProvider;

    }

    //Just a test method to show that the services can be resolved, the important bit is the call to ActivatorUtilities.CreateInstance

    public IEnumerable<IService> GetServices()

    {

        return ServiceTypes.Select(t => ActivatorUtilities.CreateInstance(_serviceProvider, t) as IService);

    }

    private static List<Type> ServiceTypes = new List<Type>();

    private readonly IServiceProvider _serviceProvider;

}

​

public interface IServiceResolver 

{

    public IEnumerable<IService> GetServices();

}

​

public interface IService 

{

    public void Test();

}

​

public class ServiceA : IService 

{

    public void Test() => Console.WriteLine("I am service A!");

}

​

public class ServiceB : IService

{

    public ServiceB(IDependencyB dependency)

    {

        _dependency = dependency;

    }

​

    public void Test() => Console.WriteLine("I am service B! I have dependency {0}", _dependency.GetType());

    private readonly IDependencyB _dependency;

}

​

public interface IDependencyB {}

​

public class DependencyB : IDependencyB{}