Abstraction layer on top of the System.CommandLine library, that allows definining commands in a declarative way, using attributes.
$ dotnet add package DeclarativeCommandLineAttribute-driven layer on top of System.CommandLine to make the most common use cases easier to set up.
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}");
}
}
TODO:
public class MyCommand
{
}[Command]
public class MyCommand
{
[Argument]
public string MyArgument { get; set; }
}TODO:
[Command]
public class MyCommand
{
[Option]
public string MyOption { get; set; }
}TODO:
TODO
[RootCommand]
public class AppRootCommand
{
[CommandHandler]
public void Handle()
{
}
}TODO
[RootCommand]
public class AppRootCommand
{
[CommandBuilder]
public void Handle(System.CommandLine.Command command)
{
}
}TODO
TODO
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; }
}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()}");
}
}my-app.exe dir current
CURRENT: C:\path\to\net6.0
TODO