Cara terbaik untuk mem-parsing argumen baris perintah di C #? [Tutup]

Saat membuat aplikasi konsol yang mengambil parameter, Anda dapat menggunakan argumen yang diteruskan ke Main(string[] args).

Di masa lalu saya hanya mengindeks / mengulang array itu dan melakukan beberapa ekspresi reguler untuk mengekstraksi nilai-nilai. Namun, ketika perintah menjadi lebih rumit, parsing bisa menjadi sangat jelek.

Jadi saya tertarik pada:

• Perpustakaan yang Anda gunakan
• Pola yang Anda gunakan

Asumsikan perintah selalu mematuhi standar umum seperti dijawab di sini .

Saya akan sangat menyarankan menggunakan NDesk.Options ( Dokumentasi ) dan / atau Mono.Options (API yang sama, namespace yang berbeda). Sebuah contoh dari dokumentasi :

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;
}

Saya sangat suka Perpustakaan Parser Command Line ( http://commandline.codeplex.com/ ). Ini memiliki cara yang sangat sederhana dan elegan untuk mengatur parameter melalui atribut:

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

The WPF TestApi perpustakaan dilengkapi dengan salah satu parser baris perintah paling baik untuk C # pembangunan. Saya sangat merekomendasikan untuk melihatnya, dari blog Ivo Manolov di 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);

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

Sepertinya semua orang memiliki parser baris perintah hewan peliharaan mereka sendiri, angka saya lebih baik menambahkan milik saya juga :).

http://bizark.codeplex.com/

Pustaka ini berisi parser baris perintah yang akan menginisialisasi kelas dengan nilai-nilai dari baris perintah. Ini memiliki banyak fitur (saya telah membangunnya selama bertahun-tahun).

Dari dokumentasi ...

Penguraian baris perintah dalam kerangka kerja BizArk memiliki fitur-fitur utama berikut:

• Inisialisasi otomatis: Properti kelas diatur secara otomatis berdasarkan argumen baris perintah.
• Properti default: Kirim nilai tanpa menentukan nama properti.
• Konversi nilai: Menggunakan kelas ConvertEx yang kuat juga termasuk dalam BizArk untuk mengkonversi nilai ke tipe yang tepat.
• Bendera Boolean: Bendera dapat ditentukan dengan hanya menggunakan argumen (ex, / b untuk true dan / b- untuk false) atau dengan menambahkan nilai true / false, ya / tidak, dll.
• Array argumen: Cukup tambahkan beberapa nilai setelah nama baris perintah untuk mengatur properti yang didefinisikan sebagai array. Ex, / x 1 2 3 akan mengisi x dengan array {1, 2, 3} (dengan asumsi x didefinisikan sebagai array bilangan bulat).
• Alias-command-line: Properti dapat mendukung beberapa alias-command-line untuknya. Misalnya, Bantuan menggunakan alias?
• Pengenalan nama sebagian: Anda tidak perlu mengeja nama lengkap atau alias, cukup mengeja saja agar parser tidak membedakan properti / alias dari yang lain.
• Mendukung ClickOnce: Dapat menginisialisasi properti bahkan ketika mereka ditentukan sebagai string kueri dalam URL untuk aplikasi yang dikerahkan ClickOnce. Metode inisialisasi baris perintah akan mendeteksi apakah itu berjalan sebagai ClickOnce atau tidak sehingga kode Anda tidak perlu berubah saat menggunakannya.
• Secara otomatis membuat /? bantuan: Ini termasuk pemformatan bagus yang memperhitungkan lebar konsol.
• Muat / Simpan argumen baris perintah ke file: Ini sangat berguna jika Anda memiliki banyak argumen kompleks baris perintah yang ingin Anda jalankan berkali-kali.

Saya menulis argumen baris perintah C # parser beberapa waktu lalu. Ini di: http://www.codeplex.com/CommandLineArguments

CLAP (parser argumen baris perintah) memiliki API yang dapat digunakan dan didokumentasikan dengan sangat baik. Anda membuat metode, menjelaskan parameter. https://github.com/adrianaisemberg/CLAP

Ada banyak solusi untuk masalah ini. Untuk kelengkapan dan untuk memberikan alternatif jika seseorang menginginkan saya menambahkan jawaban ini untuk dua kelas yang berguna di perpustakaan kode google saya .

Yang pertama adalah ArgumentList yang hanya bertanggung jawab untuk parsing parameter baris perintah. Ia mengumpulkan pasangan nama-nilai yang ditentukan oleh sakelar '/ x: y' atau '-x = y' dan juga mengumpulkan daftar entri 'tak bernama'. Penggunaan dasarnya dibahas di sini , lihat kelasnya di sini .

Bagian kedua dari ini adalah CommandInterpreter yang membuat aplikasi baris perintah yang berfungsi penuh dari kelas .Net Anda. Sebagai contoh:

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)
        { ... }

Dengan kode contoh di atas Anda dapat menjalankan yang berikut:

Program.exe Melakukan sesuatu "nilai string" 5

-- atau --

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

Sesederhana itu atau serumit yang Anda inginkan. Anda dapat meninjau kode sumber , melihat bantuan , atau mengunduh biner .

Saya suka yang itu , karena Anda dapat "mendefinisikan aturan" untuk argumen, diperlukan atau tidak, ...

atau jika Anda seorang pria Unix, daripada Anda mungkin menyukai port .NET GNU Getopt .

Anda mungkin menyukai Rug saya

Pengurai argumen baris perintah yang mudah digunakan dan diperluas. Menangani: Bool, Plus / Minus, String, Daftar String, CSV, Enumeration.

Dibangun pada '/?' mode bantuan.

Dibangun pada '/ ??' dan mode generator dokumen '/? 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);
        }
    }
}

Sunting: Ini adalah proyek saya dan karenanya jawaban ini tidak boleh dilihat sebagai dukungan dari pihak ketiga. Yang mengatakan saya menggunakannya untuk setiap program berbasis baris perintah yang saya tulis, ini adalah open source dan itu adalah harapan saya bahwa orang lain dapat memperoleh manfaat dari itu.

Ada parser argumen baris perintah di http://www.codeplex.com/commonlibrarynet

Ini dapat mengurai argumen menggunakan
1. atribut
2. panggilan eksplisit
3. baris tunggal beberapa argumen ATAU array string

Ini dapat menangani hal-hal seperti berikut:

- config : Qa - startdate : $ { hari ini } - wilayah : 'New York' Settings01

Ini sangat mudah digunakan.

Ini adalah seorang pawang yang saya tulis berdasarkan Optionskelas Novell .

Yang ini ditujukan untuk aplikasi konsol yang menjalankan while (input !="exit")loop gaya, konsol interaktif seperti konsol FTP misalnya.

Contoh penggunaan:

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

Dan sumbernya:

/// <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;
    }
}

Favorit pribadi saya adalah http://www.codeproject.com/KB/recipes/plossum_commandline.aspx oleh 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;
}

Saya baru-baru ini menemukan implementasi parsing baris perintah FubuCore saya sangat menyukainya, alasannya adalah:

• mudah digunakan - walaupun saya tidak dapat menemukan dokumentasi untuk itu, solusi FubuCore juga menyediakan proyek yang berisi set Unit Tes yang bagus yang berbicara lebih banyak tentang fungsionalitas daripada dokumentasi apa pun yang bisa
• ia memiliki desain berorientasi objek yang bagus, tidak ada pengulangan kode atau hal-hal lain yang saya gunakan di aplikasi parsing baris perintah
• itu deklaratif: pada dasarnya Anda menulis kelas untuk Perintah dan set parameter dan menghiasnya dengan atribut untuk mengatur berbagai opsi (misalnya nama, deskripsi, wajib / opsional)
• perpustakaan bahkan mencetak Grafik Penggunaan yang bagus, berdasarkan definisi ini

Di bawah ini adalah contoh sederhana tentang cara menggunakan ini. Untuk menggambarkan penggunaannya, saya telah menulis sebuah utilitas sederhana yang memiliki dua perintah: - tambah (tambahkan objek ke daftar - objek terdiri dari nama (string), nilai (int) dan bendera boolean) - daftar (daftar semua objek yang saat ini ditambahkan)

Pertama-tama, saya menulis kelas Command untuk perintah '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;
    }
}

Perintah ini menggunakan instance CommandInput sebagai parameter, jadi saya mendefinisikannya selanjutnya:

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; }
}

Perintah selanjutnya adalah 'daftar', yang diimplementasikan sebagai berikut:

[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;
    }
}

Perintah 'list' tidak mengambil parameter, jadi saya mendefinisikan kelas NullInput untuk ini:

public class NullInput { }

Yang tersisa sekarang adalah memasang ini di metode Main (), seperti ini:

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

        var executor = new CommandExecutor(factory);

        executor.Execute(args);
    }

Program ini berfungsi seperti yang diharapkan, petunjuk pencetakan tentang penggunaan yang benar jika ada perintah yang tidak valid:

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

Dan contoh penggunaan untuk perintah '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.

Parsing dilakukan oleh PowerShell berdasarkan atribut yang ditentukan pada commandlets, dukungan untuk validasi, set parameter, pipelining, pelaporan kesalahan, bantuan, dan yang terbaik dari semua mengembalikan .NET objek untuk digunakan dalam commandlets lain.

Beberapa tautan yang saya temukan membantu memulai:

• Tutorial Mulai Cepat
• Panduan Pemrograman pada MSDN
• Referensi Namespace di MSDN

C # CLI adalah parsing library argumen baris perintah yang sangat sederhana yang saya tulis. Ini didokumentasikan dengan baik dan open source.

Parser Command Line Jenghis mungkin sedikit ketinggalan zaman, tetapi fitur ini sangat lengkap dan berfungsi dengan baik bagi saya.

Saya akan menyarankan perpustakaan open-source CSharpOptParse . Ini mem-parsing baris perintah dan menghidrasi objek .NET yang ditentukan pengguna dengan input baris perintah. Saya selalu beralih ke perpustakaan ini ketika menulis aplikasi konsol C #.

Silakan gunakan .net port API apache commons cli. Ini sangat bagus.

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

dan API asli untuk konsep dan pengantar

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

Kelas ad hoc yang sangat sederhana dan mudah digunakan untuk penguraian baris perintah, yang mendukung argumen default.

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"));
    }
}