namespace BlazorServerApp
{
    internal static partial class ClockDomain
    {
        private static readonly Pure.DI.ResolversTable Resolvers = new Pure.DI.ResolversTable(new Pure.DI.Pair<System.Type, System.Func<object>>[]{new Pure.DI.Pair<System.Type, System.Func<object>>(typeof(Clock.Models.IClock), () =>
        {
            return (new Clock.Models.SystemClock());
        }), new Pure.DI.Pair<System.Type, System.Func<object>>(typeof(Clock.Models.ITimer), () =>
        {
            return (new Timer(TimeSpan.FromSeconds(1)));
        }), new Pure.DI.Pair<System.Type, System.Func<object>>(typeof(Clock.ViewModels.IDispatcher), () =>
        {
            return (Dispatcher__Singleton.Shared);
        }), new Pure.DI.Pair<System.Type, System.Func<object>>(typeof(Clock.ViewModels.IClockViewModel), () =>
        {
            return (new Clock.ViewModels.ClockViewModel((new Pure.DI.ServiceProviderInstance<Clock.Models.IClock>()).Value, (new Pure.DI.ServiceProviderInstance<Clock.Models.ITimer>()).Value, (Dispatcher__Singleton.Shared)));
        }), new Pure.DI.Pair<System.Type, System.Func<object>>(typeof(Pure.DI.ServiceProviderInstance<Clock.Models.ITimer>), () =>
        {
            return (new Pure.DI.ServiceProviderInstance<Clock.Models.ITimer>());
        }), new Pure.DI.Pair<System.Type, System.Func<object>>(typeof(Pure.DI.ServiceProviderInstance<Clock.Models.IClock>), () =>
        {
            return (new Pure.DI.ServiceProviderInstance<Clock.Models.IClock>());
        })}, default(System.Func<System.Type, object, object>));
       
        private const System.UInt32 ResolversDivisor = 28U;
        private static Pure.DI.Pair<System.Type, System.Func<object>>[] ResolversBuckets = Resolvers.ResolversBuckets;
        private static System.Func<System.Type, object, object> ResolversDefaultFactory = Resolvers.ResolversDefaultFactory;

        [MethodImplAttribute((MethodImplOptions)256)]
        public static object Resolve(System.Type type)
        {
            var pair = ResolversBuckets[(uint)type.GetHashCode() % ResolversDivisor];
            do
            {
                if (pair.Key == type)
                {
                    return pair.Value();
                }

                pair = pair.Next;
            }
            while (pair != null);
            return ResolversDefaultFactory != null ? ResolversDefaultFactory(type, null) ?? new ArgumentException($"Cannot resolve an instance of the type {type.Name}.") : throw new ArgumentException($"Cannot resolve an instance of the type {type.Name}.");
        }

        private static class Dispatcher__Singleton
        {
            public static readonly Clock.ViewModels.Dispatcher Shared = new Clock.ViewModels.Dispatcher();
        }

        public static Microsoft.Extensions.DependencyInjection.IServiceCollection AddClockDomain(this Microsoft.Extensions.DependencyInjection.IServiceCollection services)
        {
            Microsoft.Extensions.DependencyInjection.IMvcBuilder builder = Microsoft.Extensions.DependencyInjection.MvcServiceCollectionExtensions.AddControllers(services);
            builder.PartManager.PopulateFeature(new Microsoft.AspNetCore.Mvc.Controllers.ControllerFeature());
            Microsoft.Extensions.DependencyInjection.Extensions.ServiceCollectionDescriptorExtensions.Replace(builder.Services, Microsoft.Extensions.DependencyInjection.ServiceDescriptor.Transient<Microsoft.AspNetCore.Mvc.Controllers.IControllerActivator, Microsoft.AspNetCore.Mvc.Controllers.ServiceBasedControllerActivator>());
            Microsoft.Extensions.DependencyInjection.ServiceCollectionServiceExtensions.AddTransient(services, serviceProvider =>
            {
                System.IServiceProvider prevServiceProvider = Pure.DI.ServiceProviderInstance.ServiceProvider;
                try
                {
                    Pure.DI.ServiceProviderInstance.ServiceProvider = serviceProvider;
                    return (Clock.ViewModels.IDispatcher)new Clock.ViewModels.Dispatcher();
                }
                finally
                {
                    Pure.DI.ServiceProviderInstance.ServiceProvider = prevServiceProvider;
                }
            });
            Microsoft.Extensions.DependencyInjection.ServiceCollectionServiceExtensions.AddTransient(services, serviceProvider =>
            {
                System.IServiceProvider prevServiceProvider = Pure.DI.ServiceProviderInstance.ServiceProvider;
                try
                {
                    Pure.DI.ServiceProviderInstance.ServiceProvider = serviceProvider;
                    return (Clock.ViewModels.IClockViewModel)new Clock.ViewModels.ClockViewModel((new Pure.DI.ServiceProviderInstance<Clock.Models.IClock>()).Value, (new Pure.DI.ServiceProviderInstance<Clock.Models.ITimer>()).Value, (Dispatcher__Singleton.Shared));
                }
                finally
                {
                    Pure.DI.ServiceProviderInstance.ServiceProvider = prevServiceProvider;
                }
            });
            Microsoft.Extensions.DependencyInjection.ServiceCollectionServiceExtensions.AddScoped(services, serviceProvider =>
            {
                System.IServiceProvider prevServiceProvider = Pure.DI.ServiceProviderInstance.ServiceProvider;
                try
                {
                    Pure.DI.ServiceProviderInstance.ServiceProvider = serviceProvider;
                    return (Clock.Models.ITimer)new Timer(TimeSpan.FromSeconds(1));
                }
                finally
                {
                    Pure.DI.ServiceProviderInstance.ServiceProvider = prevServiceProvider;
                }
            });
            Microsoft.Extensions.DependencyInjection.ServiceCollectionServiceExtensions.AddSingleton(services, serviceProvider =>
            {
                System.IServiceProvider prevServiceProvider = Pure.DI.ServiceProviderInstance.ServiceProvider;
                try
                {
                    Pure.DI.ServiceProviderInstance.ServiceProvider = serviceProvider;
                    return (Clock.Models.IClock)new Clock.Models.SystemClock();
                }
                finally
                {
                    Pure.DI.ServiceProviderInstance.ServiceProvider = prevServiceProvider;
                }
            });
            return services;
        }
    }

    internal struct ServiceProviderInstance
    {
        [System.ThreadStatic] public static System.IServiceProvider ServiceProvider;
    }

    internal struct ServiceProviderInstance<T>
    {
        public T Value => ServiceProviderInstance.ServiceProvider != null ? (T)ServiceProviderInstance.ServiceProvider.GetService(typeof(T)) : throw new System.InvalidOperationException("Cannot resolve an instance outside a container.");
    }
}

Например?

Например, скачок кода между тредами, и получение не того сервис-провайдера.

Я решал вопрос интеграции с ASP.NET

Зачем для этого регистрировать в контейнере что-то, кроме ваших собственных сервисов? Зачем вы вот это делаете:

Microsoft.Extensions.DependencyInjection.Extensions.ServiceCollectionDescriptorExtensions.Replace(builder.Services, Microsoft.Extensions.DependencyInjection.ServiceDescriptor.Transient<Microsoft.AspNetCore.Mvc.Controllers.IControllerActivator, Microsoft.AspNetCore.Mvc.Controllers.ServiceBasedControllerActivator>());

Если убрать интеграцию с ASP.NET

Вы очень, очень зря приравниваете Microsoft.Extensions.DependencyInjection к ASP.NET.

IServiceProvider нужен только привязкам с временем жизни ContainerSingleton или Scoped

Гм. Так я еще раз спрошу: а откуда ваши сервисы получают зависимости вида ILogger<T>?

Ваш подход не сработает для привязок To<>(…) с lambda функцией

Зависит исключительно от того, как вы сделаете контракт этой функции.

Этот код нужен для интеграции с ASP.NET

Нет, не нужен. Вы где-то неправильно настраиваете ASP.NET Core-сервисы.

Чтобы получить зависимость в DI нужно делать «привязку».

… и так для всех потребляемых сервисов? Вместо того, чтобы научить вашу генерилку делать это автоматически?

Вы простите за прямоту, это неюзабельно.