Version 2.6.2

        - Changed: Renamed `Cli.GetConfiguration()` to `Cli.GetParser()` and changed return type from `CommandLineConfiguration`
          to new class `CliParser`.
          This method returns a CLI parser configured for the indicated command and you can call `Parse` or `Run` methods on it.
          So you can reuse the same `CliParser` for parsing and running.
          ```c#
          var parser = Cli.GetParser<RootCliCommand>();

          var result = parser.Parse(args);

          parser.Run(args);
          ```

          Changed return type of `Cli.Parse` methods from `ParseResult` to new class `CliResult` which
          describes the results of parsing a command line input based on a specific parser configuration
          and provides methods for binding the result to definition classes.
          ```c#
          var result = Cli.Parse<RootCliCommand>(args);

          var rootCliCommand = result.Bind<RootCliCommand>();

          if (result.ParseResult.Errors.Count > 0)
          {
          }
          ```

        - Improved: More robust command binding. Introduced `CliBindingContext` for internally encapsulating binders per command build and configuration.
          For example, in previous versions, the below code worked incorrectly, i.e. second call to `Cli.Parse` with same definition type,
          overwrote the binder so the later `Bind` call did not work correctly.
          ```c#
          var result = Cli.Parse<RootCliCommand>(args);
          var result2 = Cli.Parse<RootCliCommand>(args);

          var rootCommand = result.Bind<RootCliCommand>();
          ```

Author: calacayir

docs/README.md

@@ -112,13 +112,13 @@ Cli.Run<RootCliCommand>(args, new CliSettings { EnableDefaultExceptionHandler =
 ```
 If you need to simply parse the command-line arguments without invocation, use this:
 ```c#
-var parseResult = Cli.Parse<RootCliCommand>(args);
-var rootCliCommand = parseResult.Bind<RootCliCommand>();
+var result = Cli.Parse<RootCliCommand>(args);
+var rootCliCommand = result.Bind<RootCliCommand>();
 ```
 If you need to examine the parse result, such as errors:
 ```c#
-var parseResult = Cli.Parse<RootCliCommand>(args);
-if (parseResult.Errors.Count > 0)
+var result = Cli.Parse<RootCliCommand>(args);
+if (result.ParseResult.Errors.Count > 0)
 {
 
 }

src/Directory.Build.props

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <!-- https://learn.microsoft.com/en-us/dotnet/core/project-sdk/msbuild-props#generateassemblyinfo -->
-    <VersionPrefix>2.6.0</VersionPrefix>
+    <VersionPrefix>2.6.2</VersionPrefix>
     <Product>DotMake Command-Line</Product>
     <Company>DotMake</Company>
     <!-- Copyright is also used for NuGet metadata -->

src/DotMake.CommandLine.SourceGeneration/Outputs/CliArgumentOutput.cs

@@ -114,7 +114,7 @@ public void AppendCSharpCreateString(CodeStringBuilder sb, string varName, strin
 
             if (Input.Parent.HasGetCompletionsInterface)
                 //sb.AppendLine($"{varDefaultClass}.AddCompletions(\"{Input.Symbol.Name}\", {varName}.CompletionSources);");
-                sb.AppendLine($"{varName}.CompletionSources.Add(completionContext => GetCompletions(\"{Input.Symbol.Name}\", completionContext));");
+                sb.AppendLine($"{varName}.CompletionSources.Add(completionContext => GetCompletions(\"{Input.Symbol.Name}\", bindingContext, completionContext));");
 
         }
     }

src/DotMake.CommandLine.SourceGeneration/Outputs/CliCommandOutput.cs

@@ -151,15 +151,15 @@ Instead we will use Bind method to get cached definition instance and call GetCo
                     if (ReferenceDependantInput.HasMsDependencyInjectionAbstractions || ReferenceDependantInput.HasMsDependencyInjection)
                     {
                         sb.AppendLine(ReferenceDependantInput.HasMsDependencyInjection
-                            ? "ServiceProvider = DotMake.CommandLine.CliServiceCollectionExtensions.GetServiceProviderOrDefault(null);"
-                            : "ServiceProvider = DotMake.CommandLine.CliServiceProviderExtensions.GetServiceProvider(null);");
-                        sb.AppendLine("if (ServiceProvider != null)");
+                            ? "var serviceProvider = DotMake.CommandLine.CliServiceCollectionExtensions.GetServiceProviderOrDefault(null);"
+                            : "var serviceProvider = DotMake.CommandLine.CliServiceProviderExtensions.GetServiceProvider(null);");
+                        sb.AppendLine("if (serviceProvider != null)");
                         sb.AppendIndent();
                         sb.AppendLine("return Microsoft.Extensions.DependencyInjection.ActivatorUtilities");
                         sb.AppendIndent();
                         sb.AppendIndent();
-                        sb.AppendLine($".CreateInstance<{definitionClass}>(ServiceProvider);");
-                        //in case ServiceProvider is null (i.e. not set with SetServiceProvider)
+                        sb.AppendLine($".CreateInstance<{definitionClass}>(serviceProvider);");
+                        //in case serviceProvider is null (i.e. not set with SetServiceProvider)
                         //call Activator.CreateInstance which will throw exception if class has no default constructor
                         //but at least it avoids compile time error in generated code with new()
                         sb.AppendLine();
@@ -177,22 +177,22 @@ Instead we will use Bind method to get cached definition instance and call GetCo
                     sb.AppendLine();
                     sb.AppendLine($"private System.Collections.Generic.IEnumerable<{CompletionsNamespace}.CompletionItem> GetCompletions(");
                     sb.AppendIndent();
-                    sb.AppendLine($"string propertyName, {CompletionsNamespace}.CompletionContext completionContext)");
+                    sb.AppendLine($"string propertyName, DotMake.CommandLine.CliBindingContext bindingContext, {CompletionsNamespace}.CompletionContext completionContext)");
                     using (sb.AppendBlockStart())
                     {
                         var varTargetClass = "targetClass";
 
-                        sb.AppendLine($"var {varTargetClass} = ({definitionClass}) Bind(completionContext.ParseResult);");
+                        sb.AppendLine($"var {varTargetClass} = bindingContext.Bind<{definitionClass}>(completionContext.ParseResult);");
                         sb.AppendLine();
 
-                        sb.AppendLine("//  Call the interface method with property name of option or argument");
+                        sb.AppendLine("// Call the interface method with property name of option or argument");
                         sb.AppendLine($"return {varTargetClass}.GetCompletions(propertyName, completionContext);");
                     }
                     sb.AppendLine();
                 }
 
                 sb.AppendLine("/// <inheritdoc />");
-                using (sb.AppendBlockStart($"protected override {CommandClassNamespace}.{CommandClassName} DoBuild()"))
+                using (sb.AppendBlockStart($"protected override {CommandClassNamespace}.{CommandClassName} DoBuild(DotMake.CommandLine.CliBindingContext bindingContext)"))
                 {
                     var varNamer = "Namer";
                     var varCommand = "command";
@@ -242,7 +242,7 @@ Instead we will use Bind method to get cached definition instance and call GetCo
                     }
 
                     /*
-                    From now on, we will handle this in Cli.GetConfiguration where Build() is called and command is created.
+                    From now on, we will handle this in Cli.GetParser() where Build() is called and command is created.
                     We don't want it to be recursive here, because we will also create the parents.
 
                     sb.AppendLine();
@@ -255,23 +255,21 @@ Instead we will use Bind method to get cached definition instance and call GetCo
 
                     sb.AppendLine();
                     var varParseResult = "parseResult";
-                    using (sb.AppendBlockStart($"Binder = ({varParseResult}) =>", ";"))
+                    using (sb.AppendBlockStart($"bindingContext.Binders[DefinitionType] = ({varParseResult}) =>", ";"))
                     {
                         var varTargetClass = "targetClass";
 
                         sb.AppendLine($"var {varTargetClass} = CreateInstance();");
-
+                        
                         sb.AppendLine();
-                        sb.AppendLine("//  Set the values for the parent command accessors");
+                        sb.AppendLine("// Set the values for the parent command accessors");
                         foreach (var cliParentCommandAccessorInfo in parentCommandAccessorsWithoutProblem)
                         {
-                            sb.AppendLine($"{varTargetClass}.{cliParentCommandAccessorInfo.Symbol.Name} = DotMake.CommandLine.ParseResultExtensions");
-                            sb.AppendIndent();
-                            sb.AppendLine($".Bind<{cliParentCommandAccessorInfo.Symbol.Type.ToReferenceString()}>({varParseResult});");
+                            sb.AppendLine($"{varTargetClass}.{cliParentCommandAccessorInfo.Symbol.Name} = bindingContext.Bind<{cliParentCommandAccessorInfo.Symbol.Type.ToReferenceString()}>({varParseResult});");
                         }
-
+                        
                         sb.AppendLine();
-                        sb.AppendLine("//  Set the parsed or default values for the directives");
+                        sb.AppendLine("// Set the parsed or default values for the directives");
                         for (var index = 0; index < directivesWithoutProblem.Length; index++)
                         {
                             var cliDirectiveInput = directivesWithoutProblem[index];
@@ -280,7 +278,7 @@ Instead we will use Bind method to get cached definition instance and call GetCo
                         }
 
                         sb.AppendLine();
-                        sb.AppendLine("//  Set the parsed or default values for the options");
+                        sb.AppendLine("// Set the parsed or default values for the options");
                         for (var index = 0; index < optionsWithoutProblem.Length; index++)
                         {
                             var cliOptionInfo = optionsWithoutProblem[index];
@@ -289,7 +287,7 @@ Instead we will use Bind method to get cached definition instance and call GetCo
                         }
 
                         sb.AppendLine();
-                        sb.AppendLine("//  Set the parsed or default values for the arguments");
+                        sb.AppendLine("// Set the parsed or default values for the arguments");
                         for (var index = 0; index < argumentsWithoutProblem.Length; index++)
                         {
                             var cliArgumentInfo = argumentsWithoutProblem[index];
@@ -312,13 +310,13 @@ Instead we will use Bind method to get cached definition instance and call GetCo
                     {
                         var varTargetClass = "targetClass";
 
-                        sb.AppendLine($"var {varTargetClass} = ({definitionClass}) Bind({varParseResult});");
+                        sb.AppendLine($"var {varTargetClass} = bindingContext.Bind<{definitionClass}>({varParseResult});");
                         sb.AppendLine();
 
-                        sb.AppendLine("//  Call the command handler");
+                        sb.AppendLine("// Call the command handler");
                         sb.AppendLine(isAsync
-                            ? $"var {varCliContext} = new DotMake.CommandLine.CliContext({varParseResult}, {varCancellationToken});"
-                            : $"var {varCliContext} = new DotMake.CommandLine.CliContext({varParseResult});");
+                            ? $"var {varCliContext} = new DotMake.CommandLine.CliContext(bindingContext, {varParseResult}, {varCancellationToken});"
+                            : $"var {varCliContext} = new DotMake.CommandLine.CliContext(bindingContext, {varParseResult});");
                         sb.AppendLine("var exitCode = 0;");
                         if (handlerWithoutProblem != null)
                         {

src/DotMake.CommandLine.SourceGeneration/Outputs/CliOptionOutput.cs

@@ -122,7 +122,7 @@ public void AppendCSharpCreateString(CodeStringBuilder sb, string varName, strin
 
             if (Input.Parent.HasGetCompletionsInterface)
                 //sb.AppendLine($"{varDefaultClass}.AddCompletions(\"{Input.Symbol.Name}\", {varName}.CompletionSources);");
-                sb.AppendLine($"{varName}.CompletionSources.Add(completionContext => GetCompletions(\"{Input.Symbol.Name}\", completionContext));");
+                sb.AppendLine($"{varName}.CompletionSources.Add(completionContext => GetCompletions(\"{Input.Symbol.Name}\", bindingContext, completionContext));");
         }
     }
 }