fix Global filter dependency injection NullReferenceException #209

Author: neuecc

sandbox/GeneratorSandbox/Program.cs

@@ -1,37 +1,35 @@
 using ConsoleAppFramework;
+using Microsoft.Extensions.DependencyInjection;
+using System.Threading.Tasks.Dataflow;
 
-
-args = "some-command hello --global-flag flag-value -- more args here".Split(" ");
+// args = "some-command hello --global-flag flag-value -- more args here".Split(" ");
 
 var app = ConsoleApp.Create();
+app.ConfigureServices(services => services.AddSingleton<MyService>());
 
-app.ConfigureGlobalOptions((ref ConsoleApp.GlobalOptionsBuilder builder) =>
-{
-    var flag = builder.AddGlobalOption<string>("--global-flag");
-    return new GlobalOptions(flag);
-});
-
-app.UseFilter<SomeFilter>();
-app.Add<Commands>();
-app.Run(args);
+app.UseFilter<MyFilter>();
+app.Run(["cmd", "test"]);
 
-internal record GlobalOptions(string Flag);
+public class MyService
+{
+    public void Test() => Console.WriteLine("Test");
+}
 
-internal class Commands
+internal class MyFilter(ConsoleAppFilter next, MyService myService) : ConsoleAppFilter(next)
 {
-    [Command("some-command")]
-    public void SomeCommand([Argument] string commandArg, ConsoleAppContext context)
+    public override async Task InvokeAsync(ConsoleAppContext context, CancellationToken cancellationToken)
     {
-        Console.WriteLine($"ARG: {commandArg}");
-        Console.WriteLine($"ESCAPED: {string.Join(", ", context.EscapedArguments.ToArray()!)}");
+        myService.Test();
+        await Next.InvokeAsync(context, cancellationToken);
     }
 }
 
-internal class SomeFilter(ConsoleAppFilter next) : ConsoleAppFilter(next)
+[RegisterCommands("cmd")]
+public class MyCommand
 {
-    public override async Task InvokeAsync(ConsoleAppContext context, CancellationToken cancellationToken)
+    [Command("test")]
+    public int Test()
     {
-        Console.WriteLine($"FLAG: {((GlobalOptions)context.GlobalOptions!).Flag}");
-        await Next.InvokeAsync(context, cancellationToken);
+        return 1;
     }
 }

src/ConsoleAppFramework/ConsoleAppBaseCode.cs

@@ -199,6 +199,11 @@ internal class ConsoleAppFrameworkGeneratorOptionsAttribute : Attribute
     public bool DisableNamingConversion { get; set; }
 }
 
+internal interface IFilterFactory
+{
+    public ConsoleAppFilter BuildFilter();
+}
+
 internal delegate object FuncGlobalOptionsBuilderObject(ref ConsoleApp.GlobalOptionsBuilder builder);
 
 [UnconditionalSuppressMessage("Trimming", "IL2026")]
@@ -559,7 +564,7 @@ public ConsoleAppBuilder ConfigureGlobalOptions(FuncGlobalOptionsBuilderObject c
             return this;
         }
 
-        async Task RunWithFilterAsync(string commandName, string[] args, int commandDepth, ConsoleAppFilter invoker, CancellationToken cancellationToken)
+        async Task RunWithFilterAsync(string commandName, string[] args, int commandDepth, IFilterFactory filterFactory, CancellationToken cancellationToken)
         {
             using var posixSignalHandler = PosixSignalHandler.Register(Timeout, cancellationToken);
             try
@@ -587,6 +592,7 @@ async Task RunWithFilterAsync(string commandName, string[] args, int commandDept
                     await startHostTask;
                 }
 
+                var invoker = filterFactory.BuildFilter();
                 await Task.Run(() => invoker.InvokeAsync(context, posixSignalHandler.Token)).WaitAsync(posixSignalHandler.TimeoutToken);
             }
             catch (Exception ex)

src/ConsoleAppFramework/Emitter.cs

@@ -660,7 +660,7 @@ void EmitLeafCommand(CommandWithId? command)
                     {
                         var invokerArgument = commandArgs.TrimStart(',', ' ');
                         invokerArgument = (invokerArgument != "") ? $"this, {invokerArgument}" : "this";
-                        var invokeCode = $"RunWithFilterAsync(\"{command.Command.Name}\", args, {depth}, new Command{command.Id}Invoker({invokerArgument}).BuildFilter(), cancellationToken)";
+                        var invokeCode = $"RunWithFilterAsync(\"{command.Command.Name}\", args, {depth}, new Command{command.Id}Invoker({invokerArgument}), cancellationToken)";
                         if (!isRunAsync)
                         {
                             sb.AppendLine($"{invokeCode}.GetAwaiter().GetResult();");
@@ -681,7 +681,7 @@ void EmitFilterInvoker(CommandWithId command)
             if (needsCommand) commandType = $"{commandType} command";
             if (!string.IsNullOrEmpty(commandType)) commandType = ", " + commandType;
 
-            using (sb.BeginBlock($"sealed class Command{command.Id}Invoker(ConsoleAppBuilder builder{commandType}) : ConsoleAppFilter(null!)"))
+            using (sb.BeginBlock($"sealed class Command{command.Id}Invoker(ConsoleAppBuilder builder{commandType}) : ConsoleAppFilter(null!), IFilterFactory"))
             {
                 using (sb.BeginBlock($"public ConsoleAppFilter BuildFilter()"))
                 {

tests/ConsoleAppFramework.GeneratorTests/DITest.cs

@@ -38,4 +38,69 @@ class MyClass(string name)
 }
 """, args: "--x 10 --y 20", expected: "foo:10:20");
     }
+
+    [Fact]
+    public void WithFilter()
+    {
+        verifier.Execute("""
+var app = ConsoleApp.Create();
+app.UseFilter<MyFilter>();
+app.Run(["cmd", "test"]);
+
+public class MyService
+{
+    public void Test() => Console.Write("Test");
+}
+
+internal class MyFilter(ConsoleAppFilter next, MyService myService) : ConsoleAppFilter(next)
+{
+    public override async Task InvokeAsync(ConsoleAppContext context, CancellationToken cancellationToken)
+    {
+        myService.Test();
+        await Next.InvokeAsync(context, cancellationToken);
+    }
+}
+
+[RegisterCommands("cmd")]
+public class MyCommand
+{
+    [Command("test")]
+    public int Test()
+    {
+        return 1;
+    }
+}
+
+class MiniDI : IServiceProvider
+{
+    System.Collections.Generic.Dictionary<Type, object> dict = new();
+
+    public void Register(Type type, object instance)
+    {
+        dict[type] = instance;
+    }
+
+    public object? GetService(Type serviceType)
+    {
+        return dict.TryGetValue(serviceType, out var instance) ? instance : null;
+    }
+}
+
+namespace ConsoleAppFramework
+{
+    partial class ConsoleApp
+    {
+        partial class ConsoleAppBuilder
+        {
+            partial void BuildAndSetServiceProvider(ConsoleAppContext context)
+            {
+                var di = new MiniDI();
+                di.Register(typeof(MyService), new MyService());
+                ConsoleApp.ServiceProvider = di;
+            }
+        }
+    }
+}
+""", "cmd test", "Test");
+    }
 }