Add generic factory registration for services

src/InteractiveCLI/ServiceConfigurationHelpers/DefaultServiceBuilder.cs

@@ -0,0 +1,7 @@
+namespace InteractiveCLI.ServiceConfigurationHelpers;
+
+public class DefaultServiceBuilder<TService>(IServiceCollection services, string name) : IServiceBuilder<TService> where TService : class
+{
+    public string Name { get; } = name;
+    public IServiceCollection Services { get; } = services;
+}

src/InteractiveCLI/ServiceConfigurationHelpers/DefaultServiceFactory.cs

@@ -0,0 +1,52 @@
+using Microsoft.Extensions.Options;
+
+namespace InteractiveCLI.ServiceConfigurationHelpers;
+
+public class DefaultServiceFactory<TService>(
+    IServiceProvider serviceProvider,
+    IOptionsMonitor<ServiceFactoryOptions<TService>> optionsMonitor) : IServiceFactory<TService> where TService : class
+{
+    private readonly IServiceProvider _serviceProvider = serviceProvider;
+    private readonly IOptionsMonitor<ServiceFactoryOptions<TService>> _optionsMonitor = optionsMonitor;
+
+    public TService CreateService(string name = "Default")
+    {
+        var options = _optionsMonitor.Get(name);
+
+        TService service;
+
+        if (options.CustomFactory != null)
+        {
+            // Use custom factory if provided
+            var args = GatherConstructorArguments(options);
+            service = options.CustomFactory(_serviceProvider, args);
+        }
+        else
+        {
+            // Use default creation with ActivatorUtilities
+            var args = GatherConstructorArguments(options);
+            service = (TService)ActivatorUtilities.CreateInstance(_serviceProvider, typeof(TService), args);
+        }
+
+        // Apply registered service actions
+        foreach (var action in options.ServiceActions)
+        {
+            action(service, _serviceProvider);
+        }
+
+        return service;
+    }
+
+    private object[] GatherConstructorArguments(ServiceFactoryOptions<TService> options)
+    {
+        var allArgs = new List<object>();
+
+        foreach (var argProvider in options.ConstructorArgumentProviders)
+        {
+            var args = argProvider(_serviceProvider);
+            allArgs.AddRange(args);
+        }
+
+        return allArgs.ToArray();
+    }
+}

src/InteractiveCLI/ServiceConfigurationHelpers/GenericServiceBuilderExtentions.cs

@@ -0,0 +1,83 @@
+namespace InteractiveCLI.ServiceConfigurationHelpers;
+
+public static class GenericServiceBuilderExtensions
+{
+    public static IServiceBuilder<TService> ConfigureService<TService>(
+        this IServiceBuilder<TService> builder,
+        Action<ServiceFactoryOptions<TService>> configureOptions)
+        where TService : class
+    {
+        builder.Services.Configure<ServiceFactoryOptions<TService>>(builder.Name, configureOptions);
+        return builder;
+    }
+
+    public static IServiceBuilder<TService> ConfigureService<TService>(
+        this IServiceBuilder<TService> builder,
+        Action<ServiceFactoryOptions<TService>, IServiceProvider> configureOptions)
+        where TService : class
+    {
+        builder.Services.Configure<ServiceFactoryOptions<TService>>(builder.Name, options =>
+        {
+            options.ServiceActions.Add((service, serviceProvider) =>
+            {
+                configureOptions(options, serviceProvider);
+            });
+        });
+        return builder;
+    }
+
+    public static IServiceBuilder<TService> WithConstructorArgs<TService>(
+        this IServiceBuilder<TService> builder,
+        params object[] args)
+        where TService : class
+    {
+        return builder.ConfigureService(options =>
+        {
+            options.ConstructorArgumentProviders.Add(_ => args);
+        });
+    }
+
+    public static IServiceBuilder<TService> WithConstructorArgs<TService>(
+        this IServiceBuilder<TService> builder,
+        Func<IServiceProvider, object[]> argsProvider)
+        where TService : class
+    {
+        return builder.ConfigureService(options =>
+        {
+            options.ConstructorArgumentProviders.Add(argsProvider);
+        });
+    }
+
+    public static IServiceBuilder<TService> AddServiceAction<TService>(
+        this IServiceBuilder<TService> builder,
+        Action<TService, IServiceProvider> action)
+        where TService : class
+    {
+        return builder.ConfigureService(options =>
+        {
+            options.ServiceActions.Add(action);
+        });
+    }
+
+    public static IServiceBuilder<TService> WithCustomFactory<TService>(
+        this IServiceBuilder<TService> builder,
+        Func<IServiceProvider, object[], TService> customFactory)
+        where TService : class
+    {
+        return builder.ConfigureService(options =>
+        {
+            options.CustomFactory = customFactory;
+        });
+    }
+
+    public static IServiceBuilder<TService> WithCustomFactory<TService>(
+        this IServiceBuilder<TService> builder,
+        Func<IServiceProvider, TService> customFactory)
+        where TService : class
+    {
+        return builder.ConfigureService(options =>
+        {
+            options.CustomFactory = (serviceProvider, _) => customFactory(serviceProvider);
+        });
+    }
+}

src/InteractiveCLI/ServiceConfigurationHelpers/GenericServiceCollectionExtentions.cs

@@ -0,0 +1,58 @@
+using Microsoft.Extensions.DependencyInjection.Extensions;
+
+namespace InteractiveCLI.ServiceConfigurationHelpers;
+
+public static class GenericServiceCollectionExtensions
+{
+    public static IServiceBuilder<TService> AddServiceWithFactory<TService>(
+        this IServiceCollection services,
+        string name = "Default")
+        where TService : class
+    {
+        // Register the generic factory
+        services.TryAddSingleton<IServiceFactory<TService>, DefaultServiceFactory<TService>>();
+
+        // Register named options for this service type
+        services.Configure<ServiceFactoryOptions<TService>>(name, options => { });
+
+        // Register the service using the factory
+        services.TryAddTransient<TService>(serviceProvider =>
+        {
+            var factory = serviceProvider.GetRequiredService<IServiceFactory<TService>>();
+            return factory.CreateService(name);
+        });
+
+        return new DefaultServiceBuilder<TService>(services, name);
+    }
+
+    public static IServiceBuilder<TService> AddServiceWithFactory<TService, TImplementation>(
+        this IServiceCollection services,
+        string name = "Default")
+        where TService : class
+        where TImplementation : class, TService
+    {
+        // Register the generic factory
+        services.TryAddSingleton<IServiceFactory<TService>, DefaultServiceFactory<TService>>();
+
+        // Register named options
+        services.Configure<ServiceFactoryOptions<TService>>(name, options =>
+        {
+            // Set custom factory to create TImplementation
+            options.CustomFactory = (serviceProvider, args) =>
+                (TService)ActivatorUtilities.CreateInstance(serviceProvider, typeof(TImplementation), args);
+        });
+
+        // Register the service interface
+        services.TryAddTransient<TService>(serviceProvider =>
+        {
+            var factory = serviceProvider.GetRequiredService<IServiceFactory<TService>>();
+            return factory.CreateService(name);
+        });
+
+        // Also register the concrete type
+        services.TryAddTransient<TImplementation>(serviceProvider =>
+            (TImplementation)serviceProvider.GetRequiredService<TService>());
+
+        return new DefaultServiceBuilder<TService>(services, name);
+    }
+}

src/InteractiveCLI/ServiceConfigurationHelpers/IServiceBuilder.cs

@@ -0,0 +1,7 @@
+namespace InteractiveCLI.ServiceConfigurationHelpers;
+
+public interface IServiceBuilder<TService> where TService : class
+{
+    public string Name { get; }
+    public IServiceCollection Services { get; }
+}

src/InteractiveCLI/ServiceConfigurationHelpers/IServiceFactory.cs

@@ -0,0 +1,6 @@
+namespace InteractiveCLI.ServiceConfigurationHelpers;
+
+public interface IServiceFactory<TService> where TService : class
+{
+    TService CreateService(string name = "Default");
+}

src/InteractiveCLI/ServiceConfigurationHelpers/ServiceFactoryOptions.cs

@@ -0,0 +1,8 @@
+namespace InteractiveCLI.ServiceConfigurationHelpers;
+
+public class ServiceFactoryOptions<TService> where TService : class
+{
+    public List<Action<TService, IServiceProvider>> ServiceActions { get; set; } = new();
+    public IList<Func<IServiceProvider, object[]>> ConstructorArgumentProviders { get; private set; } = new List<Func<IServiceProvider, object[]>>();
+    public Func<IServiceProvider, object[], TService>? CustomFactory { get; set; }
+}