Allow a simple implementation of enabling dependency injection

[taori]

These days it would be nice if there was a simple way of utilizing dependency injection in command line applications as well.

Currently i am using the latest version, using middleware to populate the bindingcontext with services, but that does not allow open generic registration (for easy logger registration). Perhaps that is a scenario worth keeping in mind.

[jonsequitur]

The way you're doing it is a simple approach that lets you use a dependency injection library of your choice but was intended for the 80% cases.

For more complex cases, Microsoft.Extensions.DependencyInjection is supported via the System.CommandLine.Hosting package. Would this work for you?

[taori]

The way you're doing it is a simple approach that lets you use a dependency injection library of your choice but was intended for the 80% cases.

For more complex cases, Microsoft.Extensions.DependencyInjection is supported via the System.CommandLine.Hosting package. Would this work for you?

That sounds very promising actually. Somehow i only stumbled upon DragonFruit and dotnet-suggest through the wiki of this project. I'll have a look at it and get back to this issue with feedback

[taori]

This certainly seems to be what i am looking for. What i plan on doing is having an invocation structure where i implement something like ITypedCommand<TArg1, TArg2, ...> so i can utilize constructor injection and map arguments through Attributes. Do you think this is doable right now? Essentially i need something similar to how things work with mvc actions.

[taori]

@jonsequitur This is my current state.

I can't seem to get it working unfortunately. At least i would expect it to forward input to the "testCommand" handler, but not even that appears to work.

Do you think what i am attempting to do is doable with *.Hosting?

using System;
using System.CommandLine;
using System.CommandLine.Builder;
using System.CommandLine.Hosting;
using System.CommandLine.Invocation;
using System.CommandLine.Parsing;
using System.Reflection;
using System.Threading.Tasks;
using Generator.CLI.Component.Parser;
using Generator.CLI.Dependencies;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace Generator.CLI
{
	class Program
	{
		static async Task<int> Main(string[] args)
		{
			var builder = new CommandLineBuilder()
				.UseHost(host => { host.ConfigureServices((context, services) =>
				{
					services.AddTransient(typeof(ILogger<>), typeof(Logger<>));
					services.AddTransient(typeof(ILoggerFactory), typeof(LoggerFactory));
				}); })
				.UseHelp()
				.UseTypoCorrections()
				.UseAttributedCommands()
				.UseSuggestDirective();

			var parser = builder.Build();
			var parseResult = parser.Parse("test -v hi");
			var invoke = await parseResult.InvokeAsync();
			return invoke;
		}
	}

	public static class BuilderExtensions
	{
		public static CommandLineBuilder UseAttributedCommands(this CommandLineBuilder source)
		{
			source.UseMiddleware(async (context, next) =>
			{
				var rootCommand = new RootCommand();
				var testCommand = new Command("test")
				{
					new Argument<string>("v")
				};

				// this is where i want to construct classes inject registered services and register commands to the root command
				rootCommand.AddCommand(testCommand);
				var method = typeof(BuilderExtensions).GetMethod(nameof(Test), BindingFlags.Static | BindingFlags.NonPublic);
				// testCommand.Handler = CommandHandler.Create(method, null);
				testCommand.Handler = CommandHandler.Create<string>(p => Console.WriteLine(p));
				source.AddCommand(rootCommand);
				await next.Invoke(context);
			});

			return source;
		}

		private static void Test(string param)
		{
			throw new NotImplementedException();
		}
	}
}

[taori]

I did get it to work like this:

using System;
using System.CommandLine;
using System.CommandLine.Builder;
using System.CommandLine.Hosting;
using System.CommandLine.Invocation;
using System.CommandLine.Parsing;
using System.Reflection;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;

namespace Generator.CLI
{
	class Program
	{
		static async Task<int> Main(string[] args)
		{
			var builder = new CommandLineBuilder()
				.UseHost(host => { host.ConfigureServices((context, services) =>
				{
					services.AddTransient(typeof(ILoggerFactory), typeof(LoggerFactory));
					services.AddTransient(typeof(ILogger<>), typeof(Logger<>));
				}); })
				.UseDebugDirective()
				.UseHelp()
				.UseTypoCorrections()
				.UseAttributedCommands()
				.UseSuggestDirective();

			var parser = builder.Build();
			var parseResult = parser.Parse("test -b \"parameter b\" -a \"parameter a\"");
			var invoke = await parseResult.InvokeAsync();
			return invoke;
		}
	}

	public static class BuilderExtensions
	{
		public static CommandLineBuilder UseAttributedCommands(this CommandLineBuilder source)
		{
			var method = typeof(BuilderExtensions).GetMethod(nameof(Test), BindingFlags.Static | BindingFlags.NonPublic);
			var testCommand = new Command("test");
			testCommand.AddOption(new Option("-a") { Argument = new Argument("-a"){ Arity = ArgumentArity.ExactlyOne}});
			testCommand.AddOption(new Option("-b") { Argument = new Argument("-b") { Arity = ArgumentArity.ExactlyOne } });
			testCommand.Handler = CommandHandler.Create(method, null);
			source.AddCommand(testCommand);

			return source;
		}

		private static void Test(IHost host, string a, string b)
		{
			var logger = host.Services.GetRequiredService<ILogger<Program>>();
			// logger.LogDebug("just a test really");
			Console.WriteLine(a);
			Console.WriteLine(b);
		}
	}
}

Ideally the BindingContext should also try to use the host to resolve services instead of having to go through the host for everything.

[jonsequitur]

Would your expectation be that you can inject, e.g. a parameter of ILogger<Something> directly into the Test method?

[taori]

If i am using a host yes, otherwise it would make sense if that did not work.

[jonsequitur]

Related: #671.

[lawrencek76]

The following pattern should also be enabled by making di "simple"
using constructor injection and non static methods.

    class TestCommand
    {
        MyService _service;
        TestCommand(MyService service)
        {
            _service = service;
        }

        public void Test(string a, string b)
        {
            Console.WriteLine($"hello {_service} {a} {b}");
        }
    }

attempting this today creates an exception "Unhandled exception: System.Reflection.TargetException: Non-static method requires a target."