refactoring ReadOnlyMemory args based.

Author: neuecc

sandbox/GeneratorSandbox/Program.cs

@@ -1,61 +1,39 @@
 using ConsoleAppFramework;
-using Microsoft.Extensions.DependencyInjection;
-using System.Diagnostics.CodeAnalysis;
-using System.Runtime.CompilerServices;
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
-args = ["cmd-a", "--x", "10", "--y", "20", "--int-parameter", "1000"];
-
-var app = ConsoleApp.Create();
-
-// builder: Func<ref ConsoleApp.GlobalOptionsBuilder, object>
-app.ConfigureGlobalOptions((ref builder) =>
-{
-    var dryRun = builder.AddGlobalOption<bool>("--dry-run");
-    var verbose = builder.AddGlobalOption<bool>("-v|--verbose");
-    var intParameter = builder.AddRequiredGlobalOption<int>("--int-parameter", "integer parameter");
-
-    // return value stored to ConsoleAppContext.GlobalOptions
-    return new GlobalOptions(dryRun, verbose, intParameter);
-});
-
-app.ConfigureServices((context, _, services) =>
+public static class Program
 {
-    // store global-options to DI
-    var globalOptions = (GlobalOptions)context.GlobalOptions;
-    services.AddSingleton(globalOptions);
-
-    // check global-options value to configure services
-    //services.AddLogging(logging =>
-    //{
-    //    if (globalOptions.Verbose)
-    //    {
-    //        logging.SetMinimumLevel(LogLevel.Trace);
-    //    }
-    //});
-});
+    public static void Main(string[] args)
+    {
+        var app = ConsoleApp.Create();
 
-app.ConfigureLogging((context, _, services) =>
-{
-});
+        app.Add("", (CancellationToken cancellationToken, ConsoleAppContext ctx) => { });
 
-app.Add<Commands>();
+        app.Run(args, CancellationToken.None);
 
-app.Run(args);
+    }
+}
 
-internal record GlobalOptions(bool DryRun, bool Verbose, int IntParameter);
+internal record GlobalOptions(string Flag);
 
-// get GlobalOptions from DI
-internal class Commands(GlobalOptions globalOptions)
+internal class Commands
 {
-    [Command("cmd-a")]
-    public void CommandA(int x, int y)
+    [Command("some-command")]
+    public void SomeCommand([Argument] string commandArg, ConsoleAppContext context)
     {
-        Console.WriteLine("A:" + globalOptions + ":" + (x, y));
+        Console.WriteLine($"ARG: {commandArg}");
+        Console.WriteLine($"ESCAPED: {string.Join(", ", context.EscapedArguments.ToArray()!)}");
     }
+}
 
-    [Command("cmd-b")]
-    public void CommandB(int x, int y)
+internal class SomeFilter(ConsoleAppFilter next) : ConsoleAppFilter(next)
+{
+    public override async Task InvokeAsync(ConsoleAppContext context, CancellationToken cancellationToken)
     {
-        Console.WriteLine("B:" + globalOptions + ":" + (x, y));
+        Console.WriteLine($"FLAG: {((GlobalOptions)context.GlobalOptions!).Flag}");
+        await Next.InvokeAsync(context, cancellationToken);
     }
 }

src/ConsoleAppFramework.Abstractions/ConsoleApp.Abstractions.cs

@@ -7,50 +7,88 @@ public interface IArgumentParser<T>
     static abstract bool TryParse(ReadOnlySpan<char> s, out T result);
 }
 
+/// <summary>
+/// Represents the execution context for a console application command, containing command metadata and parsed arguments.
+/// </summary>
 public record ConsoleAppContext
 {
+    /// <summary>
+    /// Gets the name of the command being executed.
+    /// </summary>
     public string CommandName { get; init; }
-    public string[] Arguments { get; init; }
+
+    /// <summary>
+    /// Gets the raw arguments passed to the application, including the command name itself.
+    /// </summary>
+    public ReadOnlyMemory<string> Arguments { get; init; }
+
+    /// <summary>
+    /// Gets the custom state object that can be used to share data across commands.
+    /// </summary>
     public object? State { get; init; }
+
+    /// <summary>
+    /// Gets the parsed global options that apply across all commands.
+    /// </summary>
     public object? GlobalOptions { get; init; }
 
+    /// <summary>
+    /// Gets the depth of the command in a nested command hierarchy. Used internally by the framework.
+    /// </summary>
     [EditorBrowsable(EditorBrowsableState.Never)]
     public int CommandDepth { get; }
 
+    /// <summary>
+    /// Gets the index of the escape separator ('--') in the arguments, or -1 if not present. Used internally by the framework.
+    /// </summary>
     [EditorBrowsable(EditorBrowsableState.Never)]
     public int EscapeIndex { get; }
 
+    /// <summary>
+    /// Gets the internal command arguments with global options removed. Used internally by the framework.
+    /// </summary>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public string[] InternalCommandArgs { get; }
+    public ReadOnlyMemory<string> InternalCommandArgs { get; }
 
+    /// <summary>
+    /// Gets the arguments intended for the current command, excluding the command name and any escaped arguments after '--'.
+    /// </summary>
     public ReadOnlySpan<string> CommandArguments
     {
         get => (EscapeIndex == -1)
-            ? Arguments.AsSpan(CommandDepth)
-            : Arguments.AsSpan(CommandDepth, EscapeIndex - CommandDepth);
+            ? Arguments.Span.Slice(CommandDepth)
+            : Arguments.Span.Slice(CommandDepth, EscapeIndex - CommandDepth);
     }
 
+    /// <summary>
+    /// Gets the arguments that appear after the escape separator ('--'), which are not parsed by the command.
+    /// Returns an empty span if no escape separator is present.
+    /// </summary>
     public ReadOnlySpan<string> EscapedArguments
     {
         get => (EscapeIndex == -1)
             ? Array.Empty<string>()
-            : Arguments.AsSpan(EscapeIndex + 1);
+            : Arguments.Span.Slice(EscapeIndex + 1);
     }
 
-    public ConsoleAppContext(string commandName, string[] arguments, string[] commandArgs, object? state, object? globalOptions, int commandDepth, int escapeIndex)
+    public ConsoleAppContext(string commandName, ReadOnlyMemory<string> arguments, ReadOnlyMemory<string> internalCommandArgs, object? state, object? globalOptions, int commandDepth, int escapeIndex)
     {
         this.CommandName = commandName;
         this.Arguments = arguments;
-        this.InternalCommandArgs = commandArgs;
+        this.InternalCommandArgs = internalCommandArgs;
         this.State = state;
         this.GlobalOptions = globalOptions;
         this.CommandDepth = commandDepth;
         this.EscapeIndex = escapeIndex;
     }
 
+    /// <summary>
+    /// Returns a string representation of all arguments joined by spaces.
+    /// </summary>
+    /// <returns>A space-separated string of all arguments.</returns>
     public override string ToString()
     {
-        return string.Join(" ", Arguments);
+        return string.Join(" ", Arguments.ToArray());
     }
 }