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


Lors de la création d'applications console prenant des paramètres, vous pouvez utiliser les arguments transmis à 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, quand les commandes deviennent plus compliquées, l'analyse peut devenir très moche.

Donc je suis intéressé par:

  • Bibliothèques que vous utilisez
  • Les modèles que vous utilisez

Supposons que les commandes respectent toujours des normes communes telles que répondu ici.


733
2018-01-29 13:33


origine


Réponses:


Je suggère 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;
}

324
2018-01-14 22:06



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 des 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();
    }
}

198
2017-09-07 07:29



le Bibliothèque WPF TestApi est livré avec l'un des plus beaux parseurs de ligne de commande pour le développement C #. Je recommande fortement de le regarder, de 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);

50
2018-01-29 14:12



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


24
2018-01-29 13:40



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

http://bizark.codeplex.com/

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

Du Documentation...

L'analyse de ligne de commande dans le framework BizArk possède les fonctionnalités suivantes:

  • Initialisation automatique: Les propriétés de classe sont automatiquement définies 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 valeur: Utilise la puissante classe ConvertEx incluse dans BizArk pour convertir les valeurs dans le bon type.
  • Drapeaux booléens: Les drapeaux peuvent être spécifiés en utilisant simplement l'argument (ex, / b pour vrai et / b- pour faux) ou en ajoutant la valeur vrai / faux, oui / non, 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 en tant que tableau. Ex, / x 1 2 3 peuplera 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 pour cela. Par exemple, l'aide utilise l'alias?
  • Reconnaissance partielle du nom: Vous n'avez pas besoin d'épeler le nom complet ou l'alias, juste épeler suffisamment pour que l'analyseur désambiguïste la propriété / alias des autres.
  • Supporte ClickOnce: Peut initialiser les propriétés même lorsqu'elles sont spécifiées en tant que chaîne de requête dans une URL pour les applications déployées ClickOnce. La méthode d'initialisation de la ligne de commande détectera si elle s'exécute en tant que ClickOnce ou non, ce qui signifie que votre code n'a pas besoin de changer lors de son utilisation.
  • Crée automatiquement /? Aidez-moi: Cela inclut un bon formatage qui prend en compte la largeur de la console.
  • Charger / Enregistrer les arguments de ligne de commande dans un fichier: Cela est particulièrement utile si vous disposez de plusieurs ensembles complexes et volumineux d'arguments de ligne de commande que vous souhaitez exécuter plusieurs fois.

14
2017-07-01 01:03



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


13
2017-12-15 07:07



TAPER (l'interpréteur d'arguments de ligne de commande) a une API utilisable et est merveilleusement documentée. Vous faites une méthode, annotant les paramètres. https://github.com/adrianaisemberg/CLAP


9
2018-03-15 15:11



Il existe de nombreuses solutions à ce problème. Pour l'exhaustivité et pour fournir l'alternative si quelqu'un désire j'ajoute cette réponse pour deux classes utiles dans mon bibliothèque de code google.

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

La deuxième partie de ceci est la 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: "valeur de chaîne"

C'est aussi simple que cela ou aussi complexe que vous le souhaitez. Vous pouvez revoir le code source, voir l'aide, ou téléchargez le binaire.


5
2018-05-11 18:25



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 gars Unix, que vous pourriez aimer le GNU Getopt .NET Port.


4
2018-01-29 13:43



Vous pouvez aimer mon Rug.Cmd

Parser d'argument de ligne de commande facile à utiliser et extensible. Handles: Bool, Plus / Minus, Chaîne, Liste de chaînes, CSV, Enumération.

Construit en '/?' mode d'aide

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

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 chaque programme basé sur une ligne de commande que j'écris, il est open source et j'espère que d'autres pourront en bénéficier.


4
2018-01-23 16:55