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

731

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 .

Paul Stovell
sumber
Diskusi sebelumnya, split-string-mengandung-perintah-parameter-ke-string-in-c # , mungkin memiliki beberapa jawaban.
gimel
1
Hai, maaf itu agak di luar topik. namun saya menggunakan "Pengaturan Aplikasi" untuk menyampaikan argumen ke aplikasi. Saya merasa cukup mudah digunakan dan tidak perlu menulis argumen / file parsing, dan tidak perlu perpustakaan tambahan. msdn.microsoft.com/en-us/library/aa730869(VS.80).aspx
hubungi saya Steve
44
@call me Steve: argumen argumen baris perintah adalah bahwa mereka dapat bervariasi per panggilan - bagaimana Anda melakukannya dengan pengaturan aplikasi?
reinierpost

Jawaban:

324

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;
}
Jonp
sumber
14
NDesk.options sangat bagus, tetapi tampaknya tidak benar-benar mendukung aplikasi konsol dengan lebih dari satu perintah yang berbeda. Jika Anda menginginkannya, coba ManyConsole yang dibuat berdasarkan NDesk.Pilihan: nuget.org/List/Packages/ManyConsole
Frank Schwieterman
5
Ketika saya memiliki satu aplikasi dengan beberapa perintah berbeda, saya "lapisan" OptionSets. Ambil mdoc ( docs.go-mono.com/index.aspx?link=man%3amdoc%281%29 ), yang memiliki OptionSet "global" ( github.com/mono/mono/blob/master/mcs/tools/ mdoc / ... ) yang mendelegasikan ke OptionSet per-perintah (misalnya github.com/mono/mono/blob/master/mcs/tools/mdoc/… )
jonp
3
NDesk tidak bekerja untuk saya. Bisa membaca argumen integer ok tapi bukan string. Variabel terus mendapatkan argumen (misalnya 's', 'a', dll) alih-alih nilai argumen (misalnya 'serverName', 'ApplicationName'). Memberi dan menggunakan 'Command Line Parser Library' sebagai gantinya. Ok sejauh ini.
Jay
2
@AshleyHenderson Untuk satu hal, ini kecil dan fleksibel. Sebagian besar solusi hanya bekerja dengan argumen bernama opsional (yaitu, tidak bisa melakukan suka git checkout master), atau argumen mereka tidak fleksibel (yaitu, tidak mendukung --foo 123= --foo=123= -f 123= -f=123dan juga -v -h= -vh).
Wernight
1
@ FrankSchwieterman yang seharusnya menjadi jawabannya sendiri. Dan terima kasih atas tipnya, ManyConsole adalah suguhan yang nyata, sangat cocok untuk saya.
quentin-starin
197

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();
    }
}
Adrian Grigore
sumber
6
Ini adalah perpustakaan yang saya tinggali juga. Saya menulis aplikasi untuk perusahaan besar yang perlu dirawat selama bertahun-tahun - perpustakaan ini telah terus diperbarui sejak 2005, tampaknya menjadi populer, ditulis oleh orang-orang yang aktif dalam komunitas C #, dan dilisensikan dalam gaya BSD jika dukungan tidak hilang.
Charles Burns
Saya merekomendasikan ini juga. Satu-satunya masalah adalah: Menentukan diizinkan kombinasi argumen (Misalnya jika memiliki langkah argumen harus memiliki sumber dan argumen dest juga) mungkin menjadi mungkin untuk melakukan dengan atribut. Tetapi Anda mungkin lebih baik melakukannya dengan logika validator Argument yang terpisah
Lyndon White
1
Saya suka kelas Opsi. Tampaknya mendukung parameter yang tidak disebutkan namanya dan bendera --recursivejuga.
Wernight
2
Saya baru saja mengujinya dan saya telah menerapkan opsi untuk aplikasi saya hanya dalam beberapa menit. Sangat mudah untuk menggunakan perpustakaan.
Trismegistos
3
Saya menemukan perpustakaan ini sangat membatasi untuk diri saya sendiri. Jika Anda memerlukan set eksklusif, Anda tidak dapat menentukan opsi yang diperlukan untuk setiap set, jadi harus memeriksanya secara manual. Anda tidak dapat menentukan persyaratan minimum untuk nilai yang tidak disebutkan namanya, Anda harus memeriksanya secara manual juga. Bantuan pembuat layar juga tidak fleksibel sama sekali. Jika perilaku perpustakaan tidak sesuai dengan kebutuhan Anda di luar kotak, Anda dapat melakukan apa saja untuk mengubahnya.
Sergey Kostrukov
50

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);
pengguna7116
sumber
19
+1. Penguraian baris perintah adalah sesuatu yang benar-benar harus datang dari vendor (yaitu Microsoft) daripada melalui alat pihak ke-3, bahkan jika dukungan vendor datang secara berputar-putar.
Joel Coehoorn
2
Yang mengatakan, jawaban yang diterima (mono) adalah hal terbaik berikutnya.
Joel Coehoorn
6
@ Joel, bagian mana yang penting dari penguraian baris perintah harus dari vendor? Apa alasanmu
greenoldman
3
@marcias: Saya pikir maksudnya mungkin Out of the Box ... seperti banyak hal :)
user7116
Perpustakaannya sangat besar! Berisi jauh lebih banyak daripada yang saya butuhkan ...
Riri
24

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

abatishchev
sumber
2
Opsi NDesk memiliki API yang sangat bagus
user35149
2
Saya akan menambahkan suara lain untuk NDesk itu berfungsi dengan baik, tidak mengganggu dan didokumentasikan dengan baik.
Terence
1
Mono.GetOptions sudah sangat tua, NDesk.Opsi jauh lebih baik (atau Mono.Opsi jika Anda suka, kelasnya sama, di sini: anonsvn.mono-project.com/source/trunk/mcs/class/Mono.Options/… )
Matt Enright
7
@Adam Oren: jawaban saya berumur 1 tahun dan 1 bulan! Struktur mono trunk telah di refactored. Kode itu sekarang ditempatkan di anonsvn.mono-project.com/viewvc/branches/mono-2-2/mcs/class/…
abatishchev
6
@Tormod: ini Mono.GetOptions yang sudah usang, bukan Mono.Options. Mono.Opsi masih dipertahankan.
jonp
14

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.
Brian
sumber
2
Saya menemukan parser baris perintah BizArk jauh lebih mudah dan lancar daripada yang lain. Sangat dianjurkan!
Boris Modylevsky
9

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

Kolonel Panic
sumber
2
Ini sangat sederhana untuk digunakan dan batu situs web mereka. Sintaksnya sangat tidak intuitif: myapp myverb -argname argvalue(harus dimiliki -argname) atau myapp -help(biasanya --help).
Wernight
@ Wight, Anda dapat menggunakan parameter IsDefault pada Verb untuk menghapusnya. Saya tidak menemukan dukungan untuk parameter posisi, tetapi saya hanya menggunakan parameter posisi ketika saya menguraikan sendiri baris perintah. Jauh lebih jelas untuk menggunakan argumen bernama diikuti oleh nilai-nilai IMHO.
Loudenvier
5

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 .

csharptest.net
sumber
4

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 .

Xn0vv3r
sumber
4

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.

Phill Tew
sumber
Hanya FYI, bahwa Anda harus menaruh sedikit penafian bahwa Anda berafiliasi dengan proyek Rug.Cmd (sebagaimana disebutkan dalam FAQ): stackoverflow.com/faq#promotion - Bukan masalah besar karena Anda mempromosikan open- proyek sumber, tetapi masih bagus untuk menambahkan disclaimer;) +1 by the way ... terlihat cukup baik dilakukan.
Jason Down
Cheers untuk menunjukkan itu dan terima kasih untuk +1, saya akan memastikan saya lebih eksplisit tentang afiliasi saya.
Phill Tew
Jangan khawatir ... ada beberapa penabrak di luar sana untuk jenis hal ini (saya bukan salah satu dari mereka), jadi saya ingin memberi orang kepala di atas. Sekali lagi, biasanya bukan masalah untuk proyek sumber terbuka. Ini sebagian besar untuk menghentikan orang dari rekomendasi spam untuk produk (berbayar) mereka.
Jason Down
3

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.


sumber
2

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;
    }
}
Chris S
sumber
2

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;
}
Raphael Bossek
sumber
2

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
  -------------------------------------
Cristian Lupascu
sumber
2

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:

hannasm
sumber
2

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

Bernard
sumber
Didokumentasikan dengan baik? Di mana dokumentasinya?
Suhas
Ada dokumentasi internal (yaitu dalam basis kode) serta dokumentasi eksternal (lihat Readme.mkdfile di Documentationfolder).
Bernard
Ok, saya berkomentar dengan tergesa-gesa. Mungkin Anda dapat memindahkan proyek Anda ke github dan dokumentasi Anda secara otomatis mulai muncul di beranda.
Suhas
0

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 #.

Stuart Lange
sumber
0

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"));
    }
}
Martin Lütken
sumber