Attribute-driven layer on top of System.CommandLine to make the most common use cases easier to set up.
Minimalistic Example
The very smallest a command can be:
using DeclarativeCommandLine;
[Command]
public class AddNumbersCommand : ICommand
{
[Option]
public int NumberA { get; set; }
[Option]
public int NumberB { get; set; }
public void Execute()
{
Console.WriteLine($"{NumberA} + {NumberB} = {NumberA + NumberB}");
}
}
[Command]
public class MyCommand
{
[Argument]
public string MyArgument { get; set; }
}
TODO:
Name
Description
DefaultValue
ArgumentArity Arity
Completions
FromAmong
HelpName
IsHidden
LegalFileNamesOnly
LegalFilePathsOnly
Options
[Command]
public class MyCommand
{
[Option]
public string MyOption { get; set; }
}
TODO:
Name
Aliases
DefaultValue
Description
ArgumentHelpName
AllowMultipleArgumentsPerToken
ArgumentArity Arity
Completions
FromAmong
IsRequired
IsGlobal
IsHidden
LegalFileNamesOnly
LegalFilePathsOnly
Command Handlers
TODO
[RootCommand]
public class AppRootCommand
{
[CommandHandler]
public void Handle()
{
}
}
Command Builders
TODO
[RootCommand]
public class AppRootCommand
{
[CommandBuilder]
public void Handle(System.CommandLine.Command command)
{
}
}
Command Inheritance
TODO
Dependency Injection
TODO
Root Command
Generally, an app has exactly 1 "root command", which handles the case where no explicit command is specified.
For example, with an argument:
my-app.exe C:/path/to/file.txt
With an option:
my-app.exe --verbose
Cases like these are handled through the root command. If no root command is defined, an empty default root command is used, to cut down on boilerplate.
But one can be defined explicitly, like this:
[RootCommand]
public class AppRootCommand
{
[Argument]
public string MyFirstArgument { get; set; }
[Option]
public bool Verbose { get; set; }
}
Command Hierarchy
Commands can be arranged in a hierarchy, to add structure and share arguments and options.
Here's a couple example commands that illustrate the concept.
my-app.exe file create my-file.txt
my-app.exe dir create my-dir
We could define the commands as:
[Command("file")]
public class FileCommand
{
}
[Command("create", Parent = typeof(FileCommand))]
public class CreateFileCommand
{
[Argument]
public string FileName { get; set; }
[CommandHandler]
public void Handle()
{
File.WriteAllText(FileName, string.Empty);
}
}
[Command("dir")]
public class DirCommand
{
}
[Command("create", Parent = typeof(DirCommand))]
public class CreateDirCommand
{
[Argument]
public string DirName { get; set; }
[CommandHandler]
public void Handle()
{
Directory.CreateDirectory(DirName);
}
}
We can now add more commands under these, for example:
[Command("current", Parent = typeof(DirCommand))]
public class CurrentDirCommand
{
[CommandHandler]
public void Handle()
{
Console.WriteLine($"CURRENT: {Directory.GetCurrentDirectory()}");
}
}
