move subcommands to new parser

src/Microsoft.DotNet.Cli.Utils/PathUtility.cs

@@ -313,9 +313,12 @@ namespace Microsoft.DotNet.Tools.Common
             return Path.GetFullPath(path);
         }
 
-        public static void EnsureAllPathsExist(List<string> paths, string pathDoesNotExistLocalizedFormatString)
+        public static void EnsureAllPathsExist(
+            IReadOnlyCollection<string> paths,
+            string pathDoesNotExistLocalizedFormatString)
         {
             var notExisting = new List<string>();
+
             foreach (var p in paths)
             {
                 if (!File.Exists(p))
@@ -329,7 +332,7 @@ namespace Microsoft.DotNet.Tools.Common
                 throw new GracefulException(
                     string.Join(
                         Environment.NewLine,
-                        notExisting.Select((p) => string.Format(pathDoesNotExistLocalizedFormatString, p))));
+                        notExisting.Select(p => string.Format(pathDoesNotExistLocalizedFormatString, p))));
             }
         }
     }

src/dotnet/CommandBase.cs

@@ -0,0 +1,10 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.DotNet.Cli
+{
+    public abstract class CommandBase
+    {
+        public abstract int Execute();
+    }
+}

src/dotnet/DotNetSubCommandBase.cs

@@ -1,16 +0,0 @@
-// Copyright (c) .NET Foundation and contributors. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-using Microsoft.DotNet.Cli.CommandLine;
-
-namespace Microsoft.DotNet.Cli
-{
-    internal abstract class DotNetSubCommandBase : CommandLineApplication
-    {
-        internal DotNetSubCommandBase() : base(throwOnUnexpectedArg: false)
-        {
-        }
-
-        public abstract int Run(string fileOrDirectory);
-    }
-}

src/dotnet/DotNetTopLevelCommandBase.cs

@@ -3,12 +3,9 @@
 
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.Tools;
-using Microsoft.DotNet.Tools.Common;
 
 namespace Microsoft.DotNet.Cli
 {
@@ -18,60 +15,34 @@ namespace Microsoft.DotNet.Cli
         protected abstract string FullCommandNameLocalized { get; }
         protected abstract string ArgumentName { get; }
         protected abstract string ArgumentDescriptionLocalized { get; }
-        internal abstract List<Func<DotNetSubCommandBase>> SubCommands { get; }
+        internal abstract Dictionary<string, Func<AppliedOption, CommandBase>> SubCommands { get; }
 
         public int RunCommand(string[] args)
         {
             DebugHelper.HandleDebugSwitch(ref args);
 
-            CommandLineApplication command = new CommandLineApplication(throwOnUnexpectedArg: true)
+            var parser = Parser.Instance;
-            {
-                Name = $"dotnet {CommandName}",
-                FullName = FullCommandNameLocalized,
-            };
 
-            command.HelpOption("-h|--help");
+            var result = parser.ParseFrom($"dotnet {CommandName}", args);
 
-            command.Argument(ArgumentName, ArgumentDescriptionLocalized);
+            Reporter.Output.WriteLine(result.Diagram());
 
-            foreach (var subCommandCreator in SubCommands)
+            result.ShowHelpIfRequested();
-            {
+
-                var subCommand = subCommandCreator();
+            var subcommandName = result.Command().Name;
-                command.AddCommand(subCommand);
+
+            var create = SubCommands[subcommandName];
+
+            var command = create(result["dotnet"][CommandName]);
 
-                subCommand.OnExecute(() => {
             try
             {
-                        if (!command.Arguments.Any())
+                return command.Execute();
-                        {
-                            throw new GracefulException(CommonLocalizableStrings.RequiredArgumentNotPassed, ArgumentDescriptionLocalized);
-                        }
-
-                        var projectOrDirectory = command.Arguments.First().Value;
-                        if (string.IsNullOrEmpty(projectOrDirectory))
-                        {
-                            projectOrDirectory = PathUtility.EnsureTrailingSlash(Directory.GetCurrentDirectory());
-                        }
-
-                        return subCommand.Run(projectOrDirectory);
             }
             catch (GracefulException e)
             {
                 Reporter.Error.WriteLine(e.Message.Red());
-                        subCommand.ShowHelp();
+                result.ShowHelp();
-                        return 1;
-                    }
-                });
-            }
-
-            try
-            {
-                return command.Execute(args);
-            }
-            catch (GracefulException e)
-            {
-                Reporter.Error.WriteLine(e.Message.Red());
-                command.ShowHelp();
                 return 1;
             }
             catch (CommandParsingException e)

src/dotnet/ParseResultExtensions.cs

@@ -14,11 +14,9 @@ namespace Microsoft.DotNet.Cli
 
         public static void ShowHelpIfRequested(this ParseResult parseResult)
         {
-            if (parseResult.HasOption("help"))
+            if (parseResult.AppliedOptions.Any(o => o.HasOption("help")))
             {
-
                 // NOTE: this is a temporary stage in refactoring toward the ClicCommandLineParser being used at the CLI entry point. 
-
                 throw new HelpException(parseResult.Command().HelpView());
             }
         }

src/dotnet/Program.cs

@@ -54,7 +54,7 @@ namespace Microsoft.DotNet.Cli
             ["test"] = TestCommand.Run,
             ["vstest"] = VSTestCommand.Run,
             ["complete"] = CompleteCommand.Run,
-            ["parse"] = ParseCommand.Run,
+            ["parse"] = ParseCommand.Run
         };
 
         public static int Main(string[] args)

src/dotnet/commands/dotnet-add/AddCommandParser.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Net.Http;
 using System.Threading;
 using Microsoft.DotNet.Cli.CommandLine;
@@ -13,30 +14,40 @@ namespace Microsoft.DotNet.Cli
     internal static class AddCommandParser
     {
         public static Command Add() =>
-            Create.Command("add", 
+            Create.Command(
+                "add",
                 ".NET Add Command",
-                    Accept.ExactlyOneArgument.DefaultToCurrentDirectory(),
+                Accept.ExactlyOneArgument
-                    Create.Command("package",
+                      .DefaultToCurrentDirectory(),
+                Create.Command(
+                    "package",
                     ".NET Add Package reference Command",
                     Accept.ExactlyOneArgument
                           .WithSuggestionsFrom(QueryNuGet), CommonOptions.HelpOption(),
                     Create.Option("-v|--version",
                                   "Version for the package to be added.",
                                   Accept.ExactlyOneArgument
-                                       .With(name: "VERSION")),
+                                        .With(name: "VERSION")
+                                        .ForwardAs(o => $"--version {o.Arguments.Single()}")),
                     Create.Option("-f|--framework",
                                   "Add reference only when targetting a specific framework",
                                   Accept.ExactlyOneArgument
-                                       .With(name: "FRAMEWORK")),
+                                        .With(name: "FRAMEWORK")
+                                        .ForwardAs(o => $"--framework {o.Arguments.Single()}")),
                     Create.Option("-n|--no-restore ",
                                   "Add reference without performing restore preview and compatibility check."),
                     Create.Option("-s|--source",
-                                   "Use specific NuGet package sources to use during the restore."),
+                                  "Use specific NuGet package sources to use during the restore.",
+                                  Accept.ExactlyOneArgument
+                                        .With(name: "SOURCE")
+                                        .ForwardAs(o => $"--source {o.Arguments.Single()}")),
                     Create.Option("--package-directory",
                                   "Restore the packages to this Directory .",
                                   Accept.ExactlyOneArgument
-                                       .With(name: "PACKAGE_DIRECTORY"))),
+                                        .With(name: "PACKAGE_DIRECTORY")
-                    Create.Command("reference",
+                                        .ForwardAs(o => $"--package-directory {o.Arguments.Single()}"))),
+                Create.Command(
+                    "reference",
                     "Command to add project to project reference",
                     Accept.OneOrMoreArguments, CommonOptions.HelpOption(),
                     Create.Option("-f|--framework",

src/dotnet/commands/dotnet-add/Program.cs

@@ -3,7 +3,9 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.Add.PackageReference;
 using Microsoft.DotNet.Tools.Add.ProjectToProjectReference;
@@ -16,11 +18,22 @@ namespace Microsoft.DotNet.Tools.Add
         protected override string FullCommandNameLocalized => LocalizableStrings.NetAddCommand;
         protected override string ArgumentName => Constants.ProjectArgumentName;
         protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsProjectDescription;
-        internal override List<Func<DotNetSubCommandBase>> SubCommands =>
+
-            new List<Func<DotNetSubCommandBase>>
+        internal override Dictionary<string, Func<AppliedOption, CommandBase>> SubCommands =>
+            new Dictionary<string, Func<AppliedOption, CommandBase>>
             {
-                AddProjectToProjectReferenceCommand.Create,
+                {
-                AddPackageReferenceCommand.Create,
+                    "reference",
+                    add => new AddProjectToProjectReferenceCommand(
+                        add["reference"],
+                        add.Value<string>())
+                },
+                {
+                    "package",
+                    add => new AddPackageReferenceCommand(
+                        add["package"], 
+                        add.Value<string>())
+                }
             };
 
         public static int Run(string[] args)

src/dotnet/commands/dotnet-add/dotnet-add-package/Program.cs

@@ -1,105 +1,65 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using Microsoft.Build.Evaluation;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.Tools.Common;
 using Microsoft.DotNet.Tools.MSBuild;
 using Microsoft.DotNet.Tools.NuGet;
-using NuGet.Frameworks;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Text;
 
 namespace Microsoft.DotNet.Tools.Add.PackageReference
 {
-    internal class AddPackageReferenceCommand : DotNetSubCommandBase
+    internal class AddPackageReferenceCommand : CommandBase
     {
-        private CommandOption _versionOption;
+        private readonly AppliedOption _appliedCommand;
-        private CommandOption _frameworkOption;
-        private CommandOption _noRestoreOption;
-        private CommandOption _sourceOption;
-        private CommandOption _packageDirectoryOption;
-        private CommandArgument _packageNameArgument;
 
-        public static DotNetSubCommandBase Create()
+        private readonly string _packageId;
+        private readonly string _fileOrDirectory;
+
+        public AddPackageReferenceCommand(AppliedOption appliedCommand, string fileOrDirectory)
         {
-            var command = new AddPackageReferenceCommand
+            _appliedCommand = appliedCommand;
-            {
+            _fileOrDirectory = fileOrDirectory;
-                Name = "package",
+            _packageId = appliedCommand.Value<string>();
-                FullName = LocalizableStrings.AppFullName,
-                Description = LocalizableStrings.AppDescription,
-                HandleRemainingArguments = false
-            };
 
-            command.HelpOption("-h|--help");
             
-            command._packageNameArgument = command.Argument(
+            if ( string.IsNullOrWhiteSpace(_packageId) || _appliedCommand.Arguments.Count > 1) 
-                $"<{LocalizableStrings.CmdPackage}>",
-                LocalizableStrings.CmdPackageDescription,
-                multipleValues: false);
-
-            command._versionOption = command.Option(
-                $"-v|--version <{LocalizableStrings.CmdVersion}>",
-                description: LocalizableStrings.CmdVersionDescription,
-                optionType: CommandOptionType.SingleValue);
-
-            command._frameworkOption = command.Option(
-               $"-f|--framework <{LocalizableStrings.CmdFramework}>",
-               LocalizableStrings.CmdFrameworkDescription,
-               CommandOptionType.SingleValue);
-
-            command._noRestoreOption = command.Option(
-                "-n|--no-restore ",
-               LocalizableStrings.CmdNoRestoreDescription,
-               CommandOptionType.NoValue);
-
-            command._sourceOption = command.Option(
-                $"-s|--source <{LocalizableStrings.CmdSource}>",
-                LocalizableStrings.CmdSourceDescription,
-                CommandOptionType.SingleValue);
-
-            command._packageDirectoryOption = command.Option(
-                $"--package-directory <{LocalizableStrings.CmdPackageDirectory}>",
-                LocalizableStrings.CmdPackageDirectoryDescription,
-                CommandOptionType.SingleValue);
-
-            return command;
-        }
-
-        public override int Run(string fileOrDirectory)
-        {
-            if (_packageNameArgument.Values.Count != 1 || string.IsNullOrWhiteSpace(_packageNameArgument.Value) || RemainingArguments.Count > 0)
             { 
                 throw new GracefulException(LocalizableStrings.SpecifyExactlyOnePackageReference); 
             } 
+        }
 
+        public override int Execute()
+        {
             var projectFilePath = string.Empty;
 
-            if (!File.Exists(fileOrDirectory))
+            if (!File.Exists(_fileOrDirectory))
             {
-                projectFilePath = MsbuildProject.GetProjectFileFromDirectory(fileOrDirectory).FullName;
+                projectFilePath = MsbuildProject.GetProjectFileFromDirectory(_fileOrDirectory).FullName;
             }
             else
             {
-                projectFilePath = fileOrDirectory;
+                projectFilePath = _fileOrDirectory;
             }
 
             var tempDgFilePath = string.Empty;
 
-            if (!_noRestoreOption.HasValue())
+            if (!_appliedCommand.HasOption("no-restore"))
             {
                 // Create a Dependency Graph file for the project
                 tempDgFilePath = Path.GetTempFileName();
                 GetProjectDependencyGraph(projectFilePath, tempDgFilePath);
             }
 
-            var result = NuGetCommand.Run(TransformArgs(_packageNameArgument.Value, tempDgFilePath, projectFilePath));
+            var result = NuGetCommand.Run(
+                TransformArgs(
+                    _packageId,
+                    tempDgFilePath,
+                    projectFilePath));
             DisposeTemporaryFile(tempDgFilePath);
 
             return result;
@@ -136,7 +96,8 @@ namespace Microsoft.DotNet.Tools.Add.PackageReference
 
         private string[] TransformArgs(string packageId, string tempDgFilePath, string projectFilePath)
         {
-            var args = new List<string>(){
+            var args = new List<string>
+            {
                 "package",
                 "add",
                 "--package",
@@ -145,27 +106,11 @@ namespace Microsoft.DotNet.Tools.Add.PackageReference
                 projectFilePath
             };
 
-            if (_versionOption.HasValue())
+            args.AddRange(_appliedCommand
-            {
+                .OptionValuesToBeForwarded()
-                args.Add("--version");
+                .SelectMany(a => a.Split(' ')));
-                args.Add(_versionOption.Value());
+
-            }
+            if (_appliedCommand.HasOption("no-restore"))
-            if (_sourceOption.HasValue())
-            {
-                args.Add("--source");
-                args.Add(_sourceOption.Value());
-            }
-            if (_frameworkOption.HasValue())
-            {
-                args.Add("--framework");
-                args.Add(_frameworkOption.Value());
-            }
-            if (_packageDirectoryOption.HasValue())
-            {
-                args.Add("--package-directory");
-                args.Add(_packageDirectoryOption.Value());
-            }
-            if (_noRestoreOption.HasValue())
             {
                 args.Add("--no-restore");
             }

src/dotnet/commands/dotnet-add/dotnet-add-reference/Program.cs

@@ -1,57 +1,44 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
 using Microsoft.Build.Evaluation;
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.Common;
 using NuGet.Frameworks;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
 
 namespace Microsoft.DotNet.Tools.Add.ProjectToProjectReference
 {
-    internal class AddProjectToProjectReferenceCommand : DotNetSubCommandBase
+    internal class AddProjectToProjectReferenceCommand : CommandBase
     {
-        private CommandOption _frameworkOption;
+        private readonly AppliedOption _appliedCommand;
+        private readonly string _fileOrDirectory;
 
-        public static DotNetSubCommandBase Create()
+        public AddProjectToProjectReferenceCommand(AppliedOption appliedCommand, string fileOrDirectory)
         {
-            var command = new AddProjectToProjectReferenceCommand()
+            if (appliedCommand == null)
             {
-                Name = "reference",
+                throw new ArgumentNullException(nameof(appliedCommand));
-                FullName = LocalizableStrings.AppFullName,
+            }
-                Description = LocalizableStrings.AppDescription,
+            _appliedCommand = appliedCommand;
-                HandleRemainingArguments = true,
+            _fileOrDirectory = fileOrDirectory;
-                ArgumentSeparatorHelpText = LocalizableStrings.AppHelpText,
-            };
-
-            command.HelpOption("-h|--help");
-
-            command._frameworkOption = command.Option(
-               $"-f|--framework <{CommonLocalizableStrings.CmdFramework}>",
-               LocalizableStrings.CmdFrameworkDescription,
-               CommandOptionType.SingleValue);
-
-            return command;
         }
 
-        public override int Run(string fileOrDirectory)
+        public override int Execute()
         {
             var projects = new ProjectCollection();
-            MsbuildProject msbuildProj = MsbuildProject.FromFileOrDirectory(projects, fileOrDirectory);
+            MsbuildProject msbuildProj = MsbuildProject.FromFileOrDirectory(projects, _fileOrDirectory);
 
-            if (RemainingArguments.Count == 0)
+            var frameworkString = _appliedCommand["framework"].Value<string>();
-            {
-                throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneReferenceToAdd);
-            }
 
-            string frameworkString = _frameworkOption.Value();
+            PathUtility.EnsureAllPathsExist(_appliedCommand.Arguments, CommonLocalizableStrings.ReferenceDoesNotExist);
-            PathUtility.EnsureAllPathsExist(RemainingArguments, CommonLocalizableStrings.ReferenceDoesNotExist);
+            List<MsbuildProject> refs = _appliedCommand.Arguments
-            List<MsbuildProject> refs = RemainingArguments
                                                        .Select((r) => MsbuildProject.FromFile(projects, r))
                                                        .ToList();
 
@@ -95,11 +82,12 @@ namespace Microsoft.DotNet.Tools.Add.ProjectToProjectReference
                 }
             }
 
-            var relativePathReferences = RemainingArguments.Select((r) =>
+            var relativePathReferences = _appliedCommand.Arguments.Select((r) =>
-                PathUtility.GetRelativePath(msbuildProj.ProjectDirectory, Path.GetFullPath(r))).ToList();
+                                                                              PathUtility.GetRelativePath(msbuildProj.ProjectDirectory, Path.GetFullPath(r)))
+                                                        .ToList();
 
             int numberOfAddedReferences = msbuildProj.AddProjectToProjectReferences(
-                _frameworkOption.Value(),
+                frameworkString,
                 relativePathReferences);
 
             if (numberOfAddedReferences != 0)

src/dotnet/commands/dotnet-complete/CompleteCommandParser.cs

@@ -15,6 +15,7 @@ namespace Microsoft.DotNet.Cli
                       .With(name: "path"),
                 Create.Option("--position", "",
                               Accept.ExactlyOneArgument
-                                    .With(name: "command")));
+                                    .With(name: "command")
+                                    .MaterializeAs(o => int.Parse(o.Arguments.Single()))));
     }
 }

src/dotnet/commands/dotnet-list/Program.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.List.ProjectToProjectReferences;
 
@@ -15,10 +16,11 @@ namespace Microsoft.DotNet.Tools.List
         protected override string FullCommandNameLocalized => LocalizableStrings.NetListCommand;
         protected override string ArgumentName => Constants.ProjectArgumentName;
         protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsProjectDescription;
-        internal override List<Func<DotNetSubCommandBase>> SubCommands =>
+
-            new List<Func<DotNetSubCommandBase>>
+        internal override Dictionary<string, Func<AppliedOption, CommandBase>> SubCommands =>
+            new Dictionary<string, Func<AppliedOption, CommandBase>>
             {
-                ListProjectToProjectReferencesCommand.Create,
+                { "list", o => new ListProjectToProjectReferencesCommand(o) }
             };
 
         public static int Run(string[] args)

src/dotnet/commands/dotnet-list/dotnet-list-reference/Program.cs

@@ -1,32 +1,32 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
+using System.Linq;
 using Microsoft.Build.Evaluation;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
-using System.Linq;
 
 namespace Microsoft.DotNet.Tools.List.ProjectToProjectReferences
 {
-    internal class ListProjectToProjectReferencesCommand : DotNetSubCommandBase
+    internal class ListProjectToProjectReferencesCommand : CommandBase
     {
-        public static DotNetSubCommandBase Create()
+        private readonly string _fileOrDirectory;
-        {
-            var command = new ListProjectToProjectReferencesCommand()
-            {
-                Name = "reference",
-                FullName = LocalizableStrings.AppFullName,
-                Description = LocalizableStrings.AppDescription,
-            };
 
-            command.HelpOption("-h|--help");
+        public ListProjectToProjectReferencesCommand(AppliedOption appliedCommand)
-
+        {
-            return command;
+            if (appliedCommand == null)
+            {
+                throw new ArgumentNullException(nameof(appliedCommand));
             }
 
-        public override int Run(string fileOrDirectory)
+            _fileOrDirectory = appliedCommand.Arguments.Single();
+        }
+
+        public override int Execute()
         {
-            var msbuildProj = MsbuildProject.FromFileOrDirectory(new ProjectCollection(), fileOrDirectory);
+            var msbuildProj = MsbuildProject.FromFileOrDirectory(new ProjectCollection(), _fileOrDirectory);
 
             var p2ps = msbuildProj.GetProjectToProjectReferences();
             if (!p2ps.Any())
@@ -34,7 +34,7 @@ namespace Microsoft.DotNet.Tools.List.ProjectToProjectReferences
                 Reporter.Output.WriteLine(string.Format(
                                               CommonLocalizableStrings.NoReferencesFound,
                                               CommonLocalizableStrings.P2P,
-                    fileOrDirectory));
+                                              _fileOrDirectory));
                 return 0;
             }
 

src/dotnet/commands/dotnet-remove/Program.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.Remove.PackageReference;
 using Microsoft.DotNet.Tools.Remove.ProjectToProjectReference;
@@ -16,11 +17,12 @@ namespace Microsoft.DotNet.Tools.Remove
         protected override string FullCommandNameLocalized => LocalizableStrings.NetRemoveCommand;
         protected override string ArgumentName => Constants.ProjectArgumentName;
         protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsProjectDescription;
-        internal override List<Func<DotNetSubCommandBase>> SubCommands =>
+
-            new List<Func<DotNetSubCommandBase>>
+        internal override Dictionary<string, Func<AppliedOption, CommandBase>> SubCommands =>
+            new Dictionary<string, Func<AppliedOption, CommandBase>>
             {
-                RemoveProjectToProjectReferenceCommand.Create,
+                { "reference", o => new RemoveProjectToProjectReferenceCommand(o) },
-                RemovePackageReferenceCommand.Create
+                { "package", o => new RemovePackageReferenceCommand(o) }
             };
 
         public static int Run(string[] args)

src/dotnet/commands/dotnet-remove/dotnet-remove-package/Program.cs

@@ -1,61 +1,50 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-using Microsoft.Build.Evaluation;
+using System;
+using System.IO;
+using System.Linq;
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
-using Microsoft.DotNet.Tools.Common;
-using Microsoft.DotNet.Tools.MSBuild;
 using Microsoft.DotNet.Tools.NuGet;
-using NuGet.Frameworks;
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Text;
 
 namespace Microsoft.DotNet.Tools.Remove.PackageReference
 {
-    internal class RemovePackageReferenceCommand : DotNetSubCommandBase
+    internal class RemovePackageReferenceCommand : CommandBase
     {
+        private readonly AppliedOption _appliedCommand;
+        private readonly string _fileOrDirectory;
 
-        public static DotNetSubCommandBase Create()
+        public RemovePackageReferenceCommand(AppliedOption appliedCommand)
         {
-            var command = new RemovePackageReferenceCommand
+            if (appliedCommand == null)
             {
-                Name = "package",
+                throw new ArgumentNullException(nameof(appliedCommand));
-                FullName = LocalizableStrings.AppFullName,
-                Description = LocalizableStrings.AppDescription,
-                HandleRemainingArguments = true,
-                ArgumentSeparatorHelpText = LocalizableStrings.AppHelpText,
-            };
-
-            command.HelpOption("-h|--help");
-
-            return command;
             }
-
+            if (_appliedCommand.Arguments.Count != 1)
-        public override int Run(string fileOrDirectory)
-        {
-            if (RemainingArguments.Count != 1)
             {
                 throw new GracefulException(LocalizableStrings.SpecifyExactlyOnePackageReference);
             }
 
+            _appliedCommand = appliedCommand;
+            _fileOrDirectory = appliedCommand.Arguments.Single();
+        }
+
+        public override int Execute()
+        {
             var projectFilePath = string.Empty;
 
-            if (!File.Exists(fileOrDirectory))
+            if (!File.Exists(_fileOrDirectory))
             {
-                projectFilePath = MsbuildProject.GetProjectFileFromDirectory(fileOrDirectory).FullName;
+                projectFilePath = MsbuildProject.GetProjectFileFromDirectory(_fileOrDirectory).FullName;
             }
             else
             {
-                projectFilePath = fileOrDirectory;
+                projectFilePath = _fileOrDirectory;
             }
 
-            var packageToRemove = RemainingArguments.First();
+            var packageToRemove = _appliedCommand.Arguments.Single();
             var result = NuGetCommand.Run(TransformArgs(packageToRemove, projectFilePath));
 
             return result;
@@ -63,7 +52,8 @@ namespace Microsoft.DotNet.Tools.Remove.PackageReference
 
         private string[] TransformArgs(string packageId, string projectFilePath)
         {
-            return new string[]{
+            return new string[]
+            {
                 "package",
                 "remove",
                 "--package",

src/dotnet/commands/dotnet-remove/dotnet-remove-reference/Program.cs

@@ -1,6 +1,8 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
+using System.Linq;
 using Microsoft.Build.Evaluation;
 using Microsoft.DotNet.Cli;
 using Microsoft.DotNet.Cli.CommandLine;
@@ -8,42 +10,34 @@ using Microsoft.DotNet.Cli.Utils;
 
 namespace Microsoft.DotNet.Tools.Remove.ProjectToProjectReference
 {
-    internal class RemoveProjectToProjectReferenceCommand : DotNetSubCommandBase
+    internal class RemoveProjectToProjectReferenceCommand : CommandBase
     {
-        private CommandOption _frameworkOption;
+        private readonly AppliedOption _appliedCommand;
+        private readonly string _fileOrDirectory;
 
-        public static DotNetSubCommandBase Create()
+        public RemoveProjectToProjectReferenceCommand(AppliedOption appliedCommand)
         {
-            var command = new RemoveProjectToProjectReferenceCommand()
+            if (appliedCommand == null)
             {
-                Name = "reference",
+                throw new ArgumentNullException(nameof(appliedCommand));
-                FullName = LocalizableStrings.AppFullName,
-                Description = LocalizableStrings.AppDescription,
-                HandleRemainingArguments = true,
-                ArgumentSeparatorHelpText = LocalizableStrings.AppHelpText,
-            };
-
-            command.HelpOption("-h|--help");
-
-            command._frameworkOption = command.Option(
-               $"-f|--framework <{CommonLocalizableStrings.CmdFramework}>",
-               LocalizableStrings.CmdFrameworkDescription,
-               CommandOptionType.SingleValue);
-
-            return command;
             }
 
-        public override int Run(string fileOrDirectory)
+            if (_appliedCommand.Arguments.Count == 0)
-        {
-            var msbuildProj = MsbuildProject.FromFileOrDirectory(new ProjectCollection(), fileOrDirectory);
-            if (RemainingArguments.Count == 0)
             {
                 throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneReferenceToRemove);
             }
 
+            _appliedCommand = appliedCommand;
+            _fileOrDirectory = appliedCommand.Arguments.Single();
+        }
+
+        public override int Execute()
+        {
+            var msbuildProj = MsbuildProject.FromFileOrDirectory(new ProjectCollection(), _fileOrDirectory);
+
             int numberOfRemovedReferences = msbuildProj.RemoveProjectToProjectReferences(
-                _frameworkOption.Value(),
+                _appliedCommand["framework"].Value<string>(),
-                RemainingArguments);
+                _appliedCommand.Arguments);
 
             if (numberOfRemovedReferences != 0)
             {

src/dotnet/commands/dotnet-sln/Program.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.Sln.Add;
 using Microsoft.DotNet.Tools.Sln.List;
@@ -17,12 +18,13 @@ namespace Microsoft.DotNet.Tools.Sln
         protected override string FullCommandNameLocalized => LocalizableStrings.AppFullName;
         protected override string ArgumentName => Constants.SolutionArgumentName;
         protected override string ArgumentDescriptionLocalized => CommonLocalizableStrings.ArgumentsSolutionDescription;
-        internal override List<Func<DotNetSubCommandBase>> SubCommands =>
+
-            new List<Func<DotNetSubCommandBase>>
+        internal override Dictionary<string, Func<AppliedOption, CommandBase>> SubCommands =>
+            new Dictionary<string, Func<AppliedOption, CommandBase>>
             {
-                AddProjectToSolutionCommand.Create,
+                { "add", o => new AddProjectToSolutionCommand(o) },
-                ListProjectsInSolutionCommand.Create,
+                { "list", o => new ListProjectsInSolutionCommand(o) },
-                RemoveProjectFromSolutionCommand.Create
+                { "remove", o => new RemoveProjectFromSolutionCommand(o) }
             };
 
         public static int Run(string[] args)

src/dotnet/commands/dotnet-sln/add/Program.cs

@@ -1,49 +1,50 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
+using System.IO;
+using System.Linq;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Sln.Internal;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.Common;
-using Microsoft.DotNet.Tools.Sln;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 
 namespace Microsoft.DotNet.Tools.Sln.Add
 {
-    internal class AddProjectToSolutionCommand : DotNetSubCommandBase
+    internal class AddProjectToSolutionCommand : CommandBase
     {
-        public static DotNetSubCommandBase Create()
+        private readonly AppliedOption _appliedCommand;
-        {
+        private readonly string _fileOrDirectory;
-            var command = new AddProjectToSolutionCommand()
-            {
-                Name = "add",
-                FullName = LocalizableStrings.AddAppFullName,
-                Description = LocalizableStrings.AddSubcommandHelpText,
-                HandleRemainingArguments = true,
-                ArgumentSeparatorHelpText = LocalizableStrings.AddSubcommandHelpText,
-            };
 
-            command.HelpOption("-h|--help");
+        public AddProjectToSolutionCommand(AppliedOption appliedCommand)
+        {
+            if (appliedCommand == null)
+            {
+                throw new ArgumentNullException(nameof(appliedCommand));
+            }
+            _appliedCommand = appliedCommand;
 
-            return command;
+            _fileOrDirectory = appliedCommand.Arguments.Single();
         }
 
-        public override int Run(string fileOrDirectory)
+        public override int Execute()
         {
-            SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(fileOrDirectory);
+            SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(_fileOrDirectory);
 
-            if (RemainingArguments.Count == 0)
+            if (_appliedCommand.Arguments.Count == 0)
             {
                 throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneProjectToAdd);
             }
 
-            PathUtility.EnsureAllPathsExist(RemainingArguments, CommonLocalizableStrings.ProjectDoesNotExist);
+            PathUtility.EnsureAllPathsExist(_appliedCommand.Arguments, CommonLocalizableStrings.ProjectDoesNotExist);
-            var fullProjectPaths = RemainingArguments.Select((p) => Path.GetFullPath(p)).ToList();
+
+            var fullProjectPaths = _appliedCommand.Arguments
+                                                  .Select(Path.GetFullPath)
+                                                  .ToList();
+
+            var preAddProjectCount = slnFile.Projects.Count;
 
-            int preAddProjectCount = slnFile.Projects.Count;
             foreach (var fullProjectPath in fullProjectPaths)
             {
                 slnFile.AddProject(fullProjectPath);

src/dotnet/commands/dotnet-sln/list/Program.cs

@@ -1,33 +1,32 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
+using System.Linq;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Sln.Internal;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.Common;
-using Microsoft.DotNet.Tools.Sln;
 
 namespace Microsoft.DotNet.Tools.Sln.List
 {
-    internal class ListProjectsInSolutionCommand : DotNetSubCommandBase
+    internal class ListProjectsInSolutionCommand : CommandBase
     {
-        public static DotNetSubCommandBase Create()
+        private readonly string _fileOrDirectory;
-        {
-            var command = new ListProjectsInSolutionCommand()
-            {
-                Name = "list",
-                FullName = LocalizableStrings.ListAppFullName,
-                Description = LocalizableStrings.ListSubcommandHelpText,
-            };
 
-            command.HelpOption("-h|--help");
+        public ListProjectsInSolutionCommand(AppliedOption appliedCommand)
-
+        {
-            return command;
+            if (appliedCommand == null)
+            {
+                throw new ArgumentNullException(nameof(appliedCommand));
+            }
+            _fileOrDirectory = appliedCommand.Arguments.Single();
         }
 
-        public override int Run(string fileOrDirectory)
+        public override int Execute()
         {
-            SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(fileOrDirectory);
+            SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(_fileOrDirectory);
             if (slnFile.Projects.Count == 0)
             {
                 Reporter.Output.WriteLine(CommonLocalizableStrings.NoProjectsFound);

src/dotnet/commands/dotnet-sln/remove/Program.cs

@@ -1,49 +1,47 @@
 // Copyright (c) .NET Foundation and contributors. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System;
+using System.IO;
+using System.Linq;
 using Microsoft.DotNet.Cli;
+using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.DotNet.Cli.Sln.Internal;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.Tools.Common;
-using Microsoft.DotNet.Tools.Sln;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 
 namespace Microsoft.DotNet.Tools.Sln.Remove
 {
-    internal class RemoveProjectFromSolutionCommand : DotNetSubCommandBase
+    internal class RemoveProjectFromSolutionCommand : CommandBase
     {
-        public static DotNetSubCommandBase Create()
+        private readonly AppliedOption _appliedCommand;
-        {
+        private readonly string _fileOrDirectory;
-            var command = new RemoveProjectFromSolutionCommand()
-            {
-                Name = "remove",
-                FullName = LocalizableStrings.RemoveAppFullName,
-                Description = LocalizableStrings.RemoveSubcommandHelpText,
-                HandleRemainingArguments = true,
-                ArgumentSeparatorHelpText = LocalizableStrings.RemoveSubcommandHelpText,
-            };
 
-            command.HelpOption("-h|--help");
+        public RemoveProjectFromSolutionCommand(AppliedOption appliedCommand)
-
+        {
-            return command;
+            if (appliedCommand == null)
+            {
+                throw new ArgumentNullException(nameof(appliedCommand));
             }
 
-        public override int Run(string fileOrDirectory)
+            if (_appliedCommand.Arguments.Count == 0)
-        {
-            SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(fileOrDirectory);
-
-            if (RemainingArguments.Count == 0)
             {
                 throw new GracefulException(CommonLocalizableStrings.SpecifyAtLeastOneProjectToRemove);
             }
 
-            var relativeProjectPaths = RemainingArguments.Select((p) =>
+            _appliedCommand = appliedCommand;
+            _fileOrDirectory = appliedCommand.Arguments.Single();
+        }
+
+        public override int Execute()
+        {
+            SlnFile slnFile = SlnFileFactory.CreateFromFileOrDirectory(_fileOrDirectory);
+
+            var relativeProjectPaths = _appliedCommand.Arguments.Select(p =>
                                                                             PathUtility.GetRelativePath(
                                                                                 PathUtility.EnsureTrailingSlash(slnFile.BaseDirectory),
-                    Path.GetFullPath(p))).ToList();
+                                                                                Path.GetFullPath(p)))
+                                                      .ToList();
 
             bool slnChanged = false;
             foreach (var path in relativeProjectPaths)