La meilleure façon d'analyser les arguments de ligne de commande en C #? [fermé]

Lors de la création d'applications console qui prennent des paramètres, vous pouvez utiliser les arguments passés à Main(string[] args).

Dans le passé, j'ai simplement indexé / bouclé ce tableau et fait quelques expressions régulières pour extraire les valeurs. Cependant, lorsque les commandes deviennent plus compliquées, l'analyse peut devenir assez moche.

Je suis donc intéressé par:

• Bibliothèques que vous utilisez
• Modèles que vous utilisez

Supposons que les commandes respectent toujours des normes communes, comme indiqué ici .

Je suggérerais fortement d'utiliser NDesk.Options ( Documentation ) et / ou Mono.Options (même API, espace de noms différent). Un exemple de la documentation :

bool show_help = false;
List<string> names = new List<string> ();
int repeat = 1;

var p = new OptionSet () {
    { "n|name=", "the {NAME} of someone to greet.",
       v => names.Add (v) },
    { "r|repeat=", 
       "the number of {TIMES} to repeat the greeting.\n" + 
          "this must be an integer.",
        (int v) => repeat = v },
    { "v", "increase debug message verbosity",
       v => { if (v != null) ++verbosity; } },
    { "h|help",  "show this message and exit", 
       v => show_help = v != null },
};

List<string> extra;
try {
    extra = p.Parse (args);
}
catch (OptionException e) {
    Console.Write ("greet: ");
    Console.WriteLine (e.Message);
    Console.WriteLine ("Try `greet --help' for more information.");
    return;
}

J'aime vraiment la bibliothèque d'analyseurs de ligne de commande ( http://commandline.codeplex.com/ ). Il a une manière très simple et élégante de configurer les paramètres via des attributs:

class Options
{
    [Option("i", "input", Required = true, HelpText = "Input file to read.")]
    public string InputFile { get; set; }

    [Option(null, "length", HelpText = "The maximum number of bytes to process.")]
    public int MaximumLenght { get; set; }

    [Option("v", null, HelpText = "Print details during execution.")]
    public bool Verbose { get; set; }

    [HelpOption(HelpText = "Display this help screen.")]
    public string GetUsage()
    {
        var usage = new StringBuilder();
        usage.AppendLine("Quickstart Application 1.0");
        usage.AppendLine("Read user manual for usage instructions...");
        return usage.ToString();
    }
}

La bibliothèque WPF TestApi est livrée avec l'un des meilleurs analyseurs de ligne de commande pour le développement C #. Je recommande fortement de l'examiner, sur le blog d' Ivo Manolov sur l'API :

// EXAMPLE #2:
// Sample for parsing the following command-line:
// Test.exe /verbose /runId=10
// This sample declares a class in which the strongly-
// typed arguments are populated
public class CommandLineArguments
{
   bool? Verbose { get; set; }
   int? RunId { get; set; }
}

CommandLineArguments a = new CommandLineArguments();
CommandLineParser.ParseArguments(args, a);

Regardez http://github.com/mono/mono/tree/master/mcs/class/Mono.Options/

On dirait que tout le monde a ses propres analyseurs en ligne de commande pour animaux de compagnie, je ferais mieux d'ajouter le mien aussi :).

http://bizark.codeplex.com/

Cette bibliothèque contient un analyseur de ligne de commande qui initialisera une classe avec les valeurs de la ligne de commande. Il a une tonne de fonctionnalités (je l'ai construit pendant de nombreuses années).

Du documentation ...

L'analyse de la ligne de commande dans le cadre BizArk a ces fonctionnalités clés:

• Initialisation automatique: les propriétés de classe sont définies automatiquement en fonction des arguments de la ligne de commande.
• Propriétés par défaut: envoyez une valeur sans spécifier le nom de la propriété.
• Conversion de valeurs: utilise la puissante classe ConvertEx également incluse dans BizArk pour convertir les valeurs au type approprié.
• Drapeaux booléens: peuvent être spécifiés en utilisant simplement l'argument (ex, / b pour true et / b- pour false) ou en ajoutant la valeur true / false, yes / no, etc.
• Tableaux d'arguments: ajoutez simplement plusieurs valeurs après le nom de la ligne de commande pour définir une propriété définie comme un tableau. Ex, / x 1 2 3 remplira x avec le tableau {1, 2, 3} (en supposant que x est défini comme un tableau d'entiers).
• Alias ​​de ligne de commande: une propriété peut prendre en charge plusieurs alias de ligne de commande. Par exemple, l'aide utilise l'alias?.
• Reconnaissance partielle du nom: vous n'avez pas besoin d'épeler le nom complet ou l'alias, il suffit d'épeler suffisamment pour que l'analyseur désambiguïsera la propriété / l'alias des autres.
• Prend en charge ClickOnce: peut initialiser les propriétés même lorsqu'elles sont spécifiées comme chaîne de requête dans une URL pour les applications déployées ClickOnce. La méthode d'initialisation en ligne de commande détectera si elle s'exécute en tant que ClickOnce ou non afin que votre code n'ait pas besoin de changer lors de son utilisation.
• Crée automatiquement /? aide: Cela inclut un formatage agréable qui prend en compte la largeur de la console.
• Charger / enregistrer des arguments de ligne de commande dans un fichier: cela est particulièrement utile si vous disposez de plusieurs grands ensembles complexes d'arguments de ligne de commande que vous souhaitez exécuter plusieurs fois.

J'ai écrit un analyseur d'argument en ligne de commande C # il y a quelque temps. Son à: http://www.codeplex.com/CommandLineArguments

CLAP (analyseur d'arguments en ligne de commande) possède une API utilisable et est merveilleusement documenté. Vous créez une méthode en annotant les paramètres. https://github.com/adrianaisemberg/CLAP

Il existe de nombreuses solutions à ce problème. Pour être complet et pour fournir l'alternative si quelqu'un le souhaite, j'ajoute cette réponse pour deux classes utiles dans ma bibliothèque de codes Google .

Le premier est ArgumentList qui est uniquement responsable de l'analyse des paramètres de ligne de commande. Il collecte les paires nom-valeur définies par les commutateurs «/ x: y» ou «-x = y» et collecte également une liste d'entrées «sans nom». Son utilisation de base est discutée ici , consultez la classe ici .

La deuxième partie de ceci est le CommandInterpreter qui crée une application de ligne de commande entièrement fonctionnelle à partir de votre classe .Net. Par exemple:

using CSharpTest.Net.Commands;
static class Program
{
    static void Main(string[] args)
    {
        new CommandInterpreter(new Commands()).Run(args);
    }
    //example ‘Commands’ class:
    class Commands
    {
        public int SomeValue { get; set; }
        public void DoSomething(string svalue, int ivalue)
        { ... }

Avec l'exemple de code ci-dessus, vous pouvez exécuter ce qui suit:

Program.exe DoSomething "valeur de chaîne" 5

-- ou --

Program.exe dosomething / ivalue = 5 -svalue: "string value"

C'est aussi simple que cela ou aussi complexe que vous en avez besoin. Vous pouvez consulter le code source , afficher l'aide ou télécharger le binaire .

J'aime celui-là , parce que vous pouvez "définir des règles" pour les arguments, nécessaires ou non, ...

ou si vous êtes un type Unix, vous aimerez peut-être le port GNU Getopt .NET .

Vous aimerez peut-être mon tapis unique .

Analyseur d'arguments de ligne de commande facile à utiliser et extensible. Poignées: booléen, plus / moins, chaîne, liste de chaînes, CSV, énumération.

Construit en '/?' mode d'aide.

Construit en '/ ??' et les modes de génération de document '/? D'.

static void Main(string[] args) 
{            
    // create the argument parser
    ArgumentParser parser = new ArgumentParser("ArgumentExample", "Example of argument parsing");

    // create the argument for a string
    StringArgument StringArg = new StringArgument("String", "Example string argument", "This argument demonstrates string arguments");

    // add the argument to the parser 
    parser.Add("/", "String", StringArg);

    // parse arguemnts
    parser.Parse(args);

    // did the parser detect a /? argument 
    if (parser.HelpMode == false) 
    {
        // was the string argument defined 
        if (StringArg.Defined == true)
        {
            // write its value
            RC.WriteLine("String argument was defined");
            RC.WriteLine(StringArg.Value);
        }
    }
}

Edit: Ceci est mon projet et en tant que telle, cette réponse ne doit pas être considérée comme une approbation d'un tiers. Cela dit, je l'utilise pour tous les programmes en ligne de commande que j'écris, c'est open source et j'espère que d'autres pourront en bénéficier.

Il y a un analyseur d'arguments en ligne de commande sur http://www.codeplex.com/commonlibrarynet

Il peut analyser des arguments en utilisant
1. des attributs
2. des appels explicites
3. une seule ligne d'arguments multiples OU un tableau de chaînes

Il peut gérer des choses comme les suivantes:

- config : Qa - date de début : $ { today } - région : 'New York' Settings01

C'est très simple à utiliser.

Ceci est un gestionnaire que j'ai écrit sur la base de la Optionsclasse Novell .

Celui-ci est destiné aux applications console qui exécutent une while (input !="exit")boucle de style, une console interactive telle qu'une console FTP par exemple.

Exemple d'utilisation:

static void Main(string[] args)
{
    // Setup
    CommandHandler handler = new CommandHandler();
    CommandOptions options = new CommandOptions();

    // Add some commands. Use the v syntax for passing arguments
    options.Add("show", handler.Show)
        .Add("connect", v => handler.Connect(v))
        .Add("dir", handler.Dir);

    // Read lines
    System.Console.Write(">");
    string input = System.Console.ReadLine();

    while (input != "quit" && input != "exit")
    {
        if (input == "cls" || input == "clear")
        {
            System.Console.Clear();
        }
        else
        {
            if (!string.IsNullOrEmpty(input))
            {
                if (options.Parse(input))
                {
                    System.Console.WriteLine(handler.OutputMessage);
                }
                else
                {
                    System.Console.WriteLine("I didn't understand that command");
                }

            }

        }

        System.Console.Write(">");
        input = System.Console.ReadLine();
    }
}

Et la source:

/// <summary>
/// A class for parsing commands inside a tool. Based on Novell Options class (http://www.ndesk.org/Options).
/// </summary>
public class CommandOptions
{
    private Dictionary<string, Action<string[]>> _actions;
    private Dictionary<string, Action> _actionsNoParams;

    /// <summary>
    /// Initializes a new instance of the <see cref="CommandOptions"/> class.
    /// </summary>
    public CommandOptions()
    {
        _actions = new Dictionary<string, Action<string[]>>();
        _actionsNoParams = new Dictionary<string, Action>();
    }

    /// <summary>
    /// Adds a command option and an action to perform when the command is found.
    /// </summary>
    /// <param name="name">The name of the command.</param>
    /// <param name="action">An action delegate</param>
    /// <returns>The current CommandOptions instance.</returns>
    public CommandOptions Add(string name, Action action)
    {
        _actionsNoParams.Add(name, action);
        return this;
    }

    /// <summary>
    /// Adds a command option and an action (with parameter) to perform when the command is found.
    /// </summary>
    /// <param name="name">The name of the command.</param>
    /// <param name="action">An action delegate that has one parameter - string[] args.</param>
    /// <returns>The current CommandOptions instance.</returns>
    public CommandOptions Add(string name, Action<string[]> action)
    {
        _actions.Add(name, action);
        return this;
    }

    /// <summary>
    /// Parses the text command and calls any actions associated with the command.
    /// </summary>
    /// <param name="command">The text command, e.g "show databases"</param>
    public bool Parse(string command)
    {
        if (command.IndexOf(" ") == -1)
        {
            // No params
            foreach (string key in _actionsNoParams.Keys)
            {
                if (command == key)
                {
                    _actionsNoParams[key].Invoke();
                    return true;
                }
            }
        }
        else
        {
            // Params
            foreach (string key in _actions.Keys)
            {
                if (command.StartsWith(key) && command.Length > key.Length)
                {

                    string options = command.Substring(key.Length);
                    options = options.Trim();
                    string[] parts = options.Split(' ');
                    _actions[key].Invoke(parts);
                    return true;
                }
            }
        }

        return false;
    }
}

Mon préféré est http://www.codeproject.com/KB/recipes/plossum_commandline.aspx par Peter Palotas:

[CommandLineManager(ApplicationName="Hello World",
    Copyright="Copyright (c) Peter Palotas")]
class Options
{
   [CommandLineOption(Description="Displays this help text")]
   public bool Help = false;

   [CommandLineOption(Description = "Specifies the input file", MinOccurs=1)]
   public string Name
   {
      get { return mName; }
      set
      {
         if (String.IsNullOrEmpty(value))
            throw new InvalidOptionValueException(
                "The name must not be empty", false);
         mName = value;
      }
   }

   private string mName;
}

Je suis récemment tombé sur l'implémentation de l'analyse de la ligne de commande FubuCore Je l'aime vraiment, les raisons étant:

• il est facile à utiliser - bien que je n'aie pas pu trouver de documentation pour cela, la solution FubuCore fournit également un projet contenant un bel ensemble de tests unitaires qui parlent plus de la fonctionnalité que n'importe quelle documentation.
• il a une belle conception orientée objet, pas de répétition de code ou d'autres choses que j'avais l'habitude d'avoir dans mes applications d'analyse de ligne de commande
• c'est déclaratif: vous écrivez essentiellement des classes pour les commandes et les ensembles de paramètres et vous les décorez d'attributs pour définir diverses options (par exemple, nom, description, obligatoire / facultatif)
• la bibliothèque imprime même un joli graphique d'utilisation, basé sur ces définitions

Voici un exemple simple sur la façon de l'utiliser. Pour illustrer l'utilisation, j'ai écrit un utilitaire simple qui a deux commandes: - ajouter (ajoute un objet à une liste - un objet se compose d'un nom (chaîne), d'une valeur (int) et d'un drapeau booléen) - liste (listes tous les objets actuellement ajoutés)

Tout d'abord, j'ai écrit une classe Command pour la commande 'add':

[Usage("add", "Adds an object to the list")]
[CommandDescription("Add object", Name = "add")]
public class AddCommand : FubuCommand<CommandInput>
{
    public override bool Execute(CommandInput input)
    {
        State.Objects.Add(input); // add the new object to an in-memory collection

        return true;
    }
}

Cette commande prend une instance CommandInput comme paramètre, donc je définis cela ensuite:

public class CommandInput
{
    [RequiredUsage("add"), Description("The name of the object to add")]
    public string ObjectName { get; set; }

    [ValidUsage("add")]
    [Description("The value of the object to add")]
    public int ObjectValue { get; set; }

    [Description("Multiply the value by -1")]
    [ValidUsage("add")]
    [FlagAlias("nv")]
    public bool NegateValueFlag { get; set; }
}

La commande suivante est 'list', qui est implémentée comme suit:

[Usage("list", "List the objects we have so far")]
[CommandDescription("List objects", Name = "list")]
public class ListCommand : FubuCommand<NullInput>
{
    public override bool Execute(NullInput input)
    {
        State.Objects.ForEach(Console.WriteLine);

        return false;
    }
}

La commande 'list' ne prend aucun paramètre, j'ai donc défini une classe NullInput pour cela:

public class NullInput { }

Il ne reste plus qu'à câbler ceci dans la méthode Main (), comme ceci:

    static void Main(string[] args)
    {
        var factory = new CommandFactory();
        factory.RegisterCommands(typeof(Program).Assembly);

        var executor = new CommandExecutor(factory);

        executor.Execute(args);
    }

Le programme fonctionne comme prévu, imprimant des conseils sur l'utilisation correcte au cas où des commandes ne seraient pas valides:

  ------------------------
    Available commands:
  ------------------------
     add -> Add object
    list -> List objects
  ------------------------

Et un exemple d'utilisation de la commande 'add':

Usages for 'add' (Add object)
  add <objectname> [-nv]

  -------------------------------------------------
    Arguments
  -------------------------------------------------
     objectname -> The name of the object to add
    objectvalue -> The value of the object to add
  -------------------------------------------------

  -------------------------------------
    Flags
  -------------------------------------
    [-nv] -> Multiply the value by -1
  -------------------------------------

Commandlets Powershell.

Analyse effectuée par PowerShell sur la base des attributs spécifiés sur les commandlets, prise en charge des validations, des jeux de paramètres, du pipelining, du rapport d'erreurs, de l'aide et, mieux encore, des objets .NET renvoyés à utiliser dans d'autres commandlets.

Quelques liens que j'ai trouvé utiles pour commencer:

• Tutoriel de démarrage rapide
• Guide de programmation sur MSDN
• Référence de l'espace de noms sur MSDN

C # CLI est une bibliothèque d'analyse d'arguments en ligne de commande très simple que j'ai écrite. C'est bien documenté et open source.

L'analyseur de ligne de commande de Gengis est peut-être un peu obsolète, mais il est très complet et fonctionne assez bien pour moi.

Je suggère la bibliothèque open source CSharpOptParse . Il analyse la ligne de commande et hydrate un objet .NET défini par l'utilisateur avec l'entrée de ligne de commande. Je me tourne toujours vers cette bibliothèque lors de l'écriture d'une application console C #.

Veuillez utiliser le port .net de l'API apache commons cli. Cela fonctionne très bien.

http://sourceforge.net/projects/dotnetcli/

et l'API d'origine pour les concepts et l'introduction

http://commons.apache.org/cli/

Une classe ad hoc très simple et facile à utiliser pour l'analyse en ligne de commande, qui prend en charge les arguments par défaut.

class CommandLineArgs
{
    public static CommandLineArgs I
    {
        get
        {
            return m_instance;
        }
    }

    public  string argAsString( string argName )
    {
        if (m_args.ContainsKey(argName)) {
            return m_args[argName];
        }
        else return "";
    }

    public long argAsLong(string argName)
    {
        if (m_args.ContainsKey(argName))
        {
            return Convert.ToInt64(m_args[argName]);
        }
        else return 0;
    }

    public double argAsDouble(string argName)
    {
        if (m_args.ContainsKey(argName))
        {
            return Convert.ToDouble(m_args[argName]);
        }
        else return 0;
    }

    public void parseArgs(string[] args, string defaultArgs )
    {
        m_args = new Dictionary<string, string>();
        parseDefaults(defaultArgs );

        foreach (string arg in args)
        {
            string[] words = arg.Split('=');
            m_args[words[0]] = words[1];
        }
    }

    private void parseDefaults(string defaultArgs )
    {
        if ( defaultArgs == "" ) return;
        string[] args = defaultArgs.Split(';');

        foreach (string arg in args)
        {
            string[] words = arg.Split('=');
            m_args[words[0]] = words[1];
        }
    }

    private Dictionary<string, string> m_args = null;
    static readonly CommandLineArgs m_instance = new CommandLineArgs();
}

class Program
{
    static void Main(string[] args)
    {
        CommandLineArgs.I.parseArgs(args, "myStringArg=defaultVal;someLong=12");
        Console.WriteLine("Arg myStringArg  : '{0}' ", CommandLineArgs.I.argAsString("myStringArg"));
        Console.WriteLine("Arg someLong     : '{0}' ", CommandLineArgs.I.argAsLong("someLong"));
    }
}