UseCommandHandler not works with sub-class.

[CzBiX]

codes like this won't work.

abstract class Base : ICommandHandler
{
    protected virtual void Run()
    {}

    public Task<int> InvokeAsync(InvocationContext context)
    {
        Run();
        return Task.FromResult(0);
    }
}

class Sub : Base {}

host.UseCommandHandler<MyCommand, Sub>()

exception:

Unhandled exception. System.Reflection.TargetException: Non-static method requires a target.
   at System.Reflection.RuntimeMethodInfo.CheckConsistency(Object target)
   at System.Reflection.RuntimeMethodInfo.InvokeArgumentsCheck(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
   at System.Reflection.RuntimeMethodInfo.Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
   at System.Reflection.MethodBase.Invoke(Object obj, Object[] parameters)
   at System.CommandLine.Invocation.ModelBindingCommandHandler.InvokeAsync(InvocationContext context)
   at System.CommandLine.Invocation.InvocationPipeline.<>c__DisplayClass4_0.<<BuildInvocationChain>b__0>d.MoveNext()

[michaelherndon]

I've run into a similar issue tonight and spent a few hours digging into it and the code base.

When MethodInfo is passed to the CommandHandler.Create() method, there is no type info based on the command handler type passed along with it to instruct the BindingContext.ServiceProvider for the proper type to create when GetService(Type type) is called.

It infers the type from the methodInfo.DeclaringType. Thus if Task<int> InvokeAsync(InvocationContext invocation) is declared on a base class, the BindingContext.ServiceProvider will try to instantiate the base class rather than the subclass which was passed into the UseCommandHandler<TCommand, TCommandHandler>() method.

Thus it fails on abstract classes. If the base class isn't abstract, the dependency injection will fail on subclasses.

As a workaround, you can override the Task<int> InvokeAsync(InvocationContext invocation) in the last subclass of the command handler passed to the UseCommandHandler<TCommand, TCommandHandler>() method. This will force the methodInfo.DeclaringType to match. Not ideal for inheritance, but will at least let one work around the issue.

[michaelherndon]

Actually upon thinking about it more.. something like the code below should resolve the issue.

Since the code only add handlers if the command is the current one being invoked, perf should be minimal.

Basically the code below registers any base class types in the BindingContext and resolves to handlerType that was passed into the method.

 public static IHostBuilder UseCommandHandler(this IHostBuilder builder, Type commandType, Type handlerType)
        {
            if (!typeof(Command).IsAssignableFrom(commandType))
            {
                throw new ArgumentException($"{nameof(commandType)} must be a type of {nameof(Command)}", nameof(handlerType));
            }

            if (!typeof(ICommandHandler).IsAssignableFrom(handlerType))
            {
                throw new ArgumentException($"{nameof(handlerType)} must implement {nameof(ICommandHandler)}", nameof(handlerType));
            }

            if (builder.Properties[typeof(InvocationContext)] is InvocationContext invocation 
                && invocation.ParseResult.CommandResult.Command is Command command
                && command.GetType() == commandType)
            {
                invocation.BindingContext.AddService(handlerType, c => c.GetService<IHost>().Services.GetService(handlerType));
                var baseType = handlerType.BaseType
                while(baseType != null || baseType != typeof(object))
                {
                    invocation.BindingContext.AddService(baseType, c => c.GetService<IHost>().Services.GetService(handlerType));
                    baseType = baseType.BaseType;  // your baseType's baseType's baseType.
                }
                
                builder.ConfigureServices(services =>
                {
                    services.AddTransient(handlerType);
                });

                command.Handler = CommandHandler.Create(handlerType.GetMethod(nameof(ICommandHandler.InvokeAsync)));
            }

            return builder;
        }

[eisbaer66]

var baseType = handlerType.BaseType
while(baseType != null || baseType != typeof(object))

added two small changes to these lines:

1. added the missing ; after var baseType = handlerType.BaseType
2. changed the || to a &&

now it seems to be working fine as a workaround

complete code here:

public static IHostBuilder UseCommandHandler(this IHostBuilder builder, Type commandType, Type handlerType)
{
    if (!typeof(Command).IsAssignableFrom(commandType))
    {
        throw new ArgumentException($"{nameof(commandType)} must be a type of {nameof(Command)}", nameof(handlerType));
    }

    if (!typeof(ICommandHandler).IsAssignableFrom(handlerType))
    {
        throw new ArgumentException($"{nameof(handlerType)} must implement {nameof(ICommandHandler)}", nameof(handlerType));
    }

    if (builder.Properties[typeof(InvocationContext)] is InvocationContext invocation
        && invocation.ParseResult.CommandResult.Command is Command command
        && command.GetType() == commandType)
    {
        invocation.BindingContext.AddService(handlerType, c => c.GetService<IHost>().Services.GetService(handlerType));
        var baseType = handlerType.BaseType;
        while (baseType != null && baseType != typeof(object))
        {
            invocation.BindingContext.AddService(baseType, c => c.GetService<IHost>().Services.GetService(handlerType));
            baseType = baseType.BaseType; // your baseType's baseType's baseType.
        }

        builder.ConfigureServices(services =>
                                  {
                                      services.AddTransient(handlerType);
                                  });

        command.Handler = CommandHandler.Create(handlerType.GetMethod(nameof(ICommandHandler.InvokeAsync)));
    }

    return builder;
}

[jonsequitur]

@eisbaer66 Would you like to submit a PR?

[aayjaychan]

This issue is similar to #1153. Instead of registering base classes, mirror the fix to that issue by resolving the subclass using MethodInfo.ReflectedType instead of MethodInfo.DeclaringType in
ModelBindingCommandHandler.InvokeAsync(InvocationContext) (and MethodInfoHandlerDescriptor.ModelDescriptor) is probably a simpler fix.

[eisbaer66]

This issue is similar to #1153. Instead of registering base classes, mirror the fix to that issue by resolving the subclass using MethodInfo.ReflectedType instead of MethodInfo.DeclaringType in
ModelBindingCommandHandler.InvokeAsync(InvocationContext) (and MethodInfoHandlerDescriptor.ModelDescriptor) is probably a simpler fix.

Works like a charm 😄
Opened an other PR with those changes