Feature Request: Allow injection of existing IServiceCollection for dependency injection

[Cadtastic]

Description

Current Behavior

Currently, Console.Routing provides its own dependency injection mechanism through the RouterBuilder class with methods like .AddService<TService>(). This works well for basic scenarios but doesn't integrate with existing dependency injection containers that may already be configured elsewhere in the application.

Proposed Solution

Enhance Console.Routing to accept an already configured IServiceCollection (from Microsoft.Extensions.DependencyInjection) that would be used to resolve dependencies. This would allow Console.Routing to better integrate with applications that are already using the standard .NET dependency injection container.

Use Case

In larger applications where Console.Routing is just one component, we often have a central dependency injection container configured with all services. Having to register services again specifically for Console.Routing leads to:

1. Duplicate service registration
2. Potential inconsistencies between services
3. Inability to leverage scoped services properly
4. Additional maintenance burden when services change

Implementation Suggestion

Add a new method to the RouterBuilder class:

public RouterBuilder UseServiceCollection(IServiceCollection services)
{
    // Implementation that would use the provided service collection
    // instead of the internal service registry
    return this;
}

Or alternatively:

public RouterBuilder UseServiceProvider(IServiceProvider serviceProvider)
{
    // Implementation that would use the provided service provider
    // for resolving dependencies
    return this;
}

This would allow code like:

// Existing DI setup
var services = new ServiceCollection();
services.AddSingleton<IMyService, MyService>();
services.AddScoped<IUserService, UserService>();
var serviceProvider = services.BuildServiceProvider();

// Console.Routing setup using existing services
var router = new RouterBuilder()
    .AddAssemblyOf<Program>()
    .UseServiceProvider(serviceProvider)
    .Build();

Routing.Handle(args, router);

Additional Benefits

1. Access to the full Microsoft.Extensions.DependencyInjection feature set
2. Better integration with ASP.NET Core and other .NET applications
3. Support for scoped lifetime services
4. Consistency with modern .NET dependency injection practices

References

• [Microsoft.Extensions.DependencyInjection documentation](https://docs.microsoft.com/en-us/dotnet/core/extensions/dependency-injection)
• [ASP.NET Core Dependency Injection guidelines](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection)

[Cadtastic]

Solution:

I think I found a simple solution for adding existing IServiceCollection while also adding the Router as a Service. The Router references the applications existing service collection and is built when the app's ServiceProvider is built.

        /// <summary>
        /// Adds Console.Routing services to the specified <see cref="IServiceCollection"/>.
        /// </summary>
        /// <param name="services">The <see cref="IServiceCollection"/> to add services to.</param>
        /// <param name="configure">Optional action to configure the router builder.</param>
        /// <returns>The same service collection so that multiple calls can be chained.</returns>
        public static IServiceCollection AddConsoleRouting(this IServiceCollection services, Action<RouterBuilder> configure = null)
        {
            // Register the router as a singleton
            services.AddSingleton(sp => {
                // Create a router builder
                var builder = new RouterBuilder();

                // Apply optional configuration
                configure?.Invoke(builder);

                // Build the essential router components when resolved
                var documentation = builder.BuildDocumentation();
                var routes = new RouteCollection(builder.Discovery.DiscoverRoutes());
                var binder = builder.CreateBinder();
                var parser = new ArgumentParser();
                var writer = new RoutingWriter(documentation);
                var globals = builder.Discovery.DiscoverGlobals();

                // Get the exception handler from the builder
                var exceptionHandler = builder.GetExceptionHandler();

                // Create the router with all required parameters
                return new Router(routes, binder, parser, writer, sp, globals, exceptionHandler);
            });

            return services;
        }

Usage

    // Program.cs
    using Microsoft.Extensions.DependencyInjection;
    using ConsoleRouting;
    
    var services = new ServiceCollection();
    
    // Register your application services
    services.AddSingleton<IMyService, MyService>();
    services.AddScoped<IDataAccess, DataAccess>();
    
    // Add Console.Routing with access to your service collection
    services.AddConsoleRouting(builder => {
        builder
            .AddAssemblyOf<Program>()
            .AddXmlDocumentation()
            .AddDefaultHelp();
    });
    
    // Build the service provider
    var serviceProvider = services.BuildServiceProvider();
    
    // Handle command line arguments - Router will be built using your serviceProvider
    string[] args = Environment.GetCommandLineArgs();
    var router = serviceProvider.GetRequiredService<Router>();
    router.Handle(args);