Ecrire une application console est plutôt facile. Cependant il y a toujours une tâche fastidieuse : gérer les arguments de la ligne de commandes. Et que dire de la commande --help qui est supposée afficher une description exhaustive et compréhensible de toutes les combinaisons acceptées par l’application (et être à jour) :

En développant .NET Core, les équipes de Microsoft se sont retrouvées face à la même problématique. Ils ont donc développé une bibliothèque pour y répondre : Microsoft.Extensions.CommandLineUtils (le code est disponible sur GitHub).

Pour le moment il n’y a pas beaucoup de documentation disponible si ce n’est le projet de test. Il faut espérer que la documentation de ce projet (et de .NET Core plus généralement) s’améliore rapidement. Voici donc quelques exemples d’utilisation (non exhaustif mais suffisant pour la grande majorité des applications).

La première étape consiste à installer le package NuGet :

Install-Package Microsoft.Extensions.CommandLineUtils

La deuxième est de déclarer les informations de l’application (nom et description) ainsi que les options de base que l’on souhaite prendre en charge (--help et --version) :

static void Main(string[] args)
{
    // Description de l'application
    var app = new CommandLineApplication()
    {
        Name = "SampleApp.exe",
        FullName = "Sample App",
        Description = "Description de l'application"
    };
    // Gère les options d'aide et version
    // Pour déclarer des alias il suffit d'utiliser un |
    app.HelpOption("-?|-h|--help");
    app.VersionOption("--version", "1.0.0");
    // Code exécuté après parsing des arguments
    app.OnExecute(() => 
    { 
        Console.WriteLine("App executed"); 
        return 0;
    });
    // Parse la ligne de commande et la méthode OnExecute
    try
    {
        app.Execute(args);
    }
    catch (CommandParsingException ex)
    {
        Console.WriteLine(ex.Message);
        app.ShowHelp();
    }
}

Avec ces quelques lignes de configuration, l’application reconnait déjà différentes options :

SampleApp.exe --help
SampleApp.exe -?
SampleApp.exe –-version

Allons plus loin et exécutons quelque chose d’utile ! Une application peut permettre d’effectuer différentes tâches. Par exemple dotnet core cli dispose de plusieurs commandes dont restore, build, publish et pack. Chaque commande nécessite des arguments différents (chemins, urls, niveau de logs, etc. ) et une documentation associée. Cela se traduit dans le code par des command :

var app = new CommandLineApplication();
app.HelpOption();
app.VersionOption("--version", "1.0.0");
    
app.Command("restore", command =>
{
    // sampleapp.exe restore [root] --source <SOURCE>
    command.Description = "Restore package";
    command.HelpOption("-?|-h|--help"); // AppSample.exe restore --help
    var rootArg = command.Argument("[root]", "A list of projects or project folders to restore");
    var sourceOption = command.Option("-s|--source <SOURCE>", "Specifies a NuGet package source to use during the restore operation", CommandOptionType.SingleValue);
    command.OnExecute(() =>
    {
        var root = rootArg.Value;
        var source = sourceOption.Value();
        Console.WriteLine($"Restore: Root:{root}; Source:{source}");
        return 0;
    });
});
// TODO ajouter d'autres commandes
// Aucune commande ne match, affichons l'aide
app.OnExecute(() => 
{ 
    app.ShowHelp();
    return 0;
});

Et voilà, nous venons d’ajouter facilement la gestion de la commande restore. Le résultat est immédiat :

Comme on peut le constater, cette bibliothèque est très facile d’utilisation. Elle permet de bien séparer les différentes commandes gérées par l’application ainsi que leurs arguments/options.

Elle permet également de fournir facilement une option pour afficher une aide lisible et toujours à jour puisque basée sur le code.

En résumé, je dirais que cette bibliothèque nous réconcilie avec la ligne de commandes :)