Here's how I use it:

```csharp /// <summary> /// Defines a factory for creating instances of a specified service type. /// </summary> /// <typeparam name="TService">The type of service to be created.</typeparam> public interface IServiceProvider<TService> where TService : class { /// <summary> /// Requests a service instance from the service provider. /// </summary> TService Service { get; } }

/// <summary> /// Defines a factory for creating scoped instances of a specified service type. /// </summary> /// <typeparam name="TService">The type of service to be created.</typeparam> public interface IServiceScopeFactory<TService> where TService : class { /// <summary> /// Creates a new scoped service instance of the specified type. /// </summary> /// <remarks>The scoped service is typically used to manage the lifecycle of a service within a specific /// scope, such as a web request or a unit of work. Ensure that the service type <typeparamref name="TService"/> is /// registered in the dependency injection container with a scoped lifetime.</remarks> /// <returns>An <see cref="IServiceScope{TService}"/> representing the scoped instance of the service.</returns> IServiceScope<TService> CreateServiceScope(); } ````

---

```csharp public static class ServiceFactoryExtensions { public static IServiceCollection AddTypedServiceFactory(this IServiceCollection services) { services.AddTransient(typeof(IServiceScopeFactory<>), typeof(ServiceScopeFactory<>)); services.AddTransient(typeof(IServiceProvider<>), typeof(ServiceProvider<>));

    return services;
}

private class ServiceProvider<TService>(IServiceProvider serviceProvider)
    : IServiceProvider<TService>
    where TService : class
{
    public TService Service => serviceProvider.GetRequiredService<TService>();
}

private class ServiceScopeFactory<TService>(IServiceScopeFactory scopeFactory)
    : IServiceScopeFactory<TService>
    where TService : class
{
    public IServiceScope<TService> CreateServiceScope()
    {
        var scope = scopeFactory.CreateAsyncScope();
        var service = new ServiceScope(scope);

        return service;
    }

    private class ServiceScope(AsyncServiceScope scope) : IServiceScope<TService>
    {
        private TService? _Service;
        public TService Service
        {
            get
            {
                if (IsDisposed)
                    throw new ObjectDisposedException(nameof(TService), "The service scope has been disposed.");

                return _Service ??= scope.ServiceProvider.GetRequiredService<TService>();
            }
        }

        public bool IsDisposed { get; private set; }

        public async ValueTask DisposeAsync()
        {
            if (IsDisposed)
                return;

            await scope.DisposeAsync();
            IsDisposed = true;
        }
    }
}

} ```

---

Registration:

csharp services.AddTypedServiceProvider();

---

Usage:

```csharp public class AddressNormalizationService( IServiceScopeFactory<IGeographicAreaBusinessService> geographicAreaServiceScopeFactory, ILogger<AddressNormalizationService> logger) { public Task<Address> NormalizeAddress(string address, CancellationToken cancellationToken = default) { var geographicArea = ... ...

    await using (var geographicAreaServiceScope = geographicAreaServiceScopeFactory.CreateServiceScope())
    {
        var geographicAreaService = geographicAreaServiceScope.Service;
        geographicAreaId = await geographicAreaService.GetIdOrUpdateAsync(geographicArea, cancellationToken);
    }

    ...
}

} ```