C # 'da komut satırı bağımsız değişkenlerini ayrıştırmanın en iyi yolu? [kapalı]


731

Parametre alan konsol uygulamaları oluştururken, iletilen bağımsız değişkenleri kullanabilirsiniz Main(string[] args).

Geçmişte bu dizini dizine ekledim / döngüledim ve değerleri ayıklamak için birkaç düzenli ifade yaptım. Ancak, komutlar daha karmaşık hale geldiğinde, ayrıştırma oldukça çirkinleşebilir.

Bu yüzden ilgileniyorum:

  • Kullandığınız kütüphaneler
  • Kullandığınız desenler

Komutların her zaman burada cevaplananlar gibi ortak standartlara uygun olduğunu varsayalım .


Önceki bir tartışma, split-string-içeren-komut-line-parametreleri-string-in-c # , bazı cevaplara sahip olabilir.
gimel

1
Merhaba, üzgünüm biraz konu dışı. ancak ben argümanı uygulamaya geçirmek için "Uygulama Ayarları" kullanıyorum. Kullanımı oldukça kolay ve argüman / dosya ayrıştırma yazmaya gerek yok, ve ekstra kütüphane gerek yok. msdn.microsoft.com/tr-tr/library/aa730869(VS.80).aspx
bana Steve

44
@call me Steve: Komut satırı argümanlarının amacı, arama başına değişiklik gösterebilmeleridir - bunu uygulama ayarlarıyla nasıl yaparsınız?
reinierpost

Yanıtlar:


324

NDesk.Options ( Documentation ) ve / veya Mono.Options (aynı API, farklı ad alanı) kullanmanızı şiddetle öneririm . Belgelerden bir örnek :

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

14
NDesk.options harika, ancak birden fazla farklı komutla konsol uygulamalarını gerçekten desteklemiyor gibi görünüyor. Bunu istiyorsanız, NDesk üzerine inşa edilen ManyConsole'u deneyin.Opsiyonlar: nuget.org/List/Packages/ManyConsole
Frank Schwieterman

5
Birden fazla farklı komut içeren bir uygulamam olduğunda, OptionSets'i "katmanlandırır". MDOC (al docs.go-mono.com/index.aspx?link=man%3amdoc%281%29 "global" OptionSet (vardır), github.com/mono/mono/blob/master/mcs/tools/ mdoc /… ) komut başına OptionSet'e yetki verir (örn. github.com/mono/mono/blob/master/mcs/tools/mdoc/… )
jonp

3
NDesk benim için iş değil. Tamsayı bağımsız değişkenleri okunabilir ancak dizeler okunamaz. Değişkenler, bağımsız değişken değerleri (örneğin, 'sunucuAdı', 'UygulamaAdı') yerine bağımsız değişkenleri (örneğin 's', 'a' vb.) Almaya devam eder. Verdi ve onun yerine 'Komut Satırı Ayrıştırıcı Kitaplığı'nı kullandı. Tamam çok uzak.
Jay

2
@AshleyHenderson Bir kere, küçük ve esnektir. Çoğu çözüm yalnızca isteğe bağlı adlandırılmış bağımsız değişkenlerle çalışır (yani beğenemez git checkout master) veya bağımsız değişkenleri esnek değildir (yani --foo 123= --foo=123= -f 123= -f=123ve ayrıca -v -h= desteklemez -vh).
Wernight

1
@FrankSchwieterman kendi cevabı olmalı. Ve bahşiş için teşekkürler, ManyConsole gerçek bir muamele, benim için mükemmel uyuyor.
quentin-starin

197

Komut Satırı Ayrıştırıcı Kitaplığı'nı ( http://commandline.codeplex.com/ ) çok seviyorum . Nitelikler aracılığıyla parametreleri ayarlamanın çok basit ve zarif bir yolu vardır:

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

6
Bu benim de yerleştiğim kütüphane. Uzun yıllardır korunması gereken büyük bir şirket için başvurular yazıyorum - bu kütüphane 2005'ten beri sürekli olarak güncelleniyor, popüler görünüyor, C # topluluğunda aktif kişiler tarafından yazılıyor ve BSD tarzında lisanslanıyor destek yok olur.
Charles Burns

Bunu da tavsiye ederim. Tek sorunum: İzin verilen argüman kombinasyonunu belirtmek (örneğin, hareket argümanının kaynak ve hedef argümanları olması gerekiyorsa) niteliklerle yapmak mümkün olabilir . Ama ayrı Argument validator logic ile bunu yapmak daha iyi olabilir
Lyndon White

1
Seçenekler sınıfını seviyorum. Adsız parametreleri ve bayrakları da destekliyor gibi görünüyor --recursive.
Wernight

2
Sadece test ettim ve birkaç dakika içinde uygulamam için bir seçenek uyguladım. Kütüphaneyi kullanmak son derece basittir.
Trismegistos

3
Bu kütüphaneyi kendim için çok kısıtlayıcı buldum. Özel setlere ihtiyacınız varsa, her set için gerekli seçenekleri tanımlayamazsınız, bu yüzden bunları manuel olarak kontrol etmeniz gerekir. Adsız değerler için minimum gereksinimi tanımlayamazsınız, bunları manuel olarak da kontrol etmeniz gerekir. Yardım ekran oluşturucu da hiç esnek değil. Kütüphanenin davranışı ihtiyaçlarınıza uygun değilse, değiştirmek için neredeyse hiçbir şey yapamazsınız.
Sergey Kostrukov

50

WPF TestApi kütüphane C # geliştirme için en güzel komut satırı ayrıştırıcıları biri ile birlikte geliyor. Ivo Manolov'un API blogundan bakmanızı şiddetle tavsiye ederim :

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

19
+1. Komut satırı ayrıştırma işlemi, satıcının desteği yuvarlak bir şekilde gelse bile, üçüncü taraf bir araç yerine satıcıdan (Microsoft gibi) gerçekten gelmesi gereken bir şeydir.
Joel Coehoorn

2
Bununla birlikte, kabul edilen cevap (mono) bir sonraki en iyi şeydir.
Joel Coehoorn

6
@Joel, komut satırı ayrıştırma işleminin satıcıdan olması ne kadar önemli? Sebepleriniz neler?
greenoldman

3
@marcias: Bence muhtemelen kutudan çıkmış olması gerektiği anlamına geliyor ... bir çok şey gibi :)
user7116

Kütüphane çok büyük! İhtiyacım olandan çok daha fazlasını
içeriyor

24

2
NDesk seçenekleri çok güzel bir API'ye sahip
user35149

2
NDesk için iyi bir oy ekleyeceğim, müdahaleci olmayan ve iyi belgelenmiş.
Terence

1
Mono.GetOptions çok eski, NDesk.Options çok daha güzel (veya isterseniz Mono.Options, aynı sınıf, burada: anonsvn.mono-project.com/source/trunk/mcs/class/Mono.Options/… )
Matt Enright

7
@Adam Ören: Cevabım 1 yaşında ve 1 aylık! mono gövdenin yapısı yeniden düzenlendi. Bu kod şimdi anonsvn.mono-project.com/viewvc/branches/mono-2-2/mcs/class/…
abatishchev

6
@Tormod: Mono.Options değil eski olan Mono.GetOptions. Mono.Opsiyonlar hala korunmaktadır.
jonp

14

Herkesin kendi evcil hayvan komut satırı ayrıştırıcıları var gibi görünüyor, ben de benimkini eklemem iyi olur :).

http://bizark.codeplex.com/

Bu kütüphane bir komut satırı ayrıştırıcısı içeriyor değerlerle bir sınıfı başlatacak . Tonlarca özelliği var (uzun yıllardır inşa ediyorum).

Gönderen dokümantasyon ...

BizArk çerçevesindeki komut satırı ayrıştırma şu temel özelliklere sahiptir:

  • Otomatik başlatma: Sınıf özellikleri, komut satırı bağımsız değişkenlerine göre otomatik olarak ayarlanır.
  • Varsayılan özellikler: Özellik adını belirtmeden bir değer gönderin.
  • Değer dönüşümü: Değerleri uygun türe dönüştürmek için BizArk'ta bulunan güçlü ConvertEx sınıfını kullanır.
  • Boolean bayrakları: Bayraklar yalnızca bağımsız değişken (ex, doğru için b / ve false için / b-) kullanılarak veya true / false, yes / no vb. Değer eklenerek belirtilebilir.
  • Bağımsız değişken dizileri: Dizi olarak tanımlanan bir özelliği ayarlamak için komut satırı adından sonra birden çok değer eklemeniz yeterlidir. Örneğin, / x 1 2 3, x'i {1, 2, 3} dizisiyle dolduracaktır (x'in bir tamsayı dizisi olarak tanımlandığı varsayılarak).
  • Komut satırı takma adları: Bir özellik, bunun için birden fazla komut satırı takma adını destekleyebilir. Örneğin, Yardım diğer adı kullanıyor mu?
  • Kısmi ad tanıma: Tam adı veya diğer adı hecelemenize gerek yoktur, yalnızca ayrıştırıcının özelliği / diğer adı diğerlerinden ayırması için yeterli heceleme yapmanız yeterlidir.
  • ClickOnce'i destekler: ClickOnce tarafından dağıtılan uygulamalar için bir URL'de sorgu dizesi olarak belirtilse bile özellikleri başlatabilir. Komut satırı başlatma yöntemi, ClickOnce olarak çalışıp çalışmadığını tespit eder, bu nedenle kodunuzu kullanırken değiştirmenize gerek yoktur.
  • Otomatik olarak / oluşturur? yardım: Bu, konsolun genişliğini dikkate alan güzel biçimlendirmeyi içerir.
  • Komut satırı bağımsız değişkenlerini bir dosyaya Yükle / Kaydet: Bu, özellikle birden çok kez çalıştırmak istediğiniz çok sayıda büyük, karmaşık komut satırı bağımsız değişkeni kümeniz varsa kullanışlıdır.

2
BizArk'ın komut satırı ayrıştırıcısını diğerlerinden çok daha kolay ve akıcı buldum. Şiddetle tavsiye edilir!
Boris Modylevsky


9

CLAP (komut satırı bağımsız değişken ayrıştırıcısı) kullanılabilir bir API'ye sahiptir ve mükemmel şekilde belgelenmiştir. Parametrelere açıklama ekleyerek bir yöntem yaparsınız. https://github.com/adrianaisemberg/CLAP


2
Kullanımı çok basit ve web sitesi sallıyor. Ancak sözdizimleri çok sezgisel değil: myapp myverb -argname argvalue(olması gerekir -argname) veya myapp -help(yaygın olarak --help).
Wernight

@Wernight, Verb üzerindeki IsDefault parametresini atlanabilir. Konumsal parametreler için destek bulamadım, ancak yalnızca komut satırını ayrıştırırken konumsal parametreleri kullandım. Adlandırılmış bağımsız değişkenleri ve ardından IMHO değerlerini kullanmak çok daha net.
Loudenvier

5

Bu soruna çok sayıda çözüm var. Tamlık ve birileri isterse alternatif sağlamak için google kod kütüphanemde iki yararlı sınıf için bu yanıtı ekliyorum .

Birincisi, yalnızca komut satırı parametrelerini ayrıştırmaktan sorumlu ArgumentList. '/ X: y' veya '-x = y' anahtarlarıyla tanımlanan ad-değer çiftlerini toplar ve ayrıca 'adsız' girişlerin bir listesini toplar. It temel kullanım burada tartışılmaktadır , burada sınıfını görmek .

Bunun ikinci kısmı .Net sınıfınızdan tamamen işlevsel bir komut satırı uygulaması oluşturan CommandInterpreter'dir . Örnek olarak:

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

Yukarıdaki örnek kodla aşağıdakileri çalıştırabilirsiniz:

Program.exe DoSomething "dize değeri" 5

- veya -

Program.exe dosomething / ivalue = 5 -svalue: "dize değeri"

Bu kadar basit veya ihtiyacınız olduğu kadar karmaşık. Sen edebilir kaynak kodunu incelemek , yardımına bakın veya ikili indirmek .



4

Benimkini beğenebilirsin Rug.Cmd

Kullanımı kolay ve genişletilebilir komut satırı bağımsız değişken ayrıştırıcısı. Kolları: Bool, Artı / Eksi, Dize, Dize Listesi, CSV, Numaralandırma.

Yerleşik '/?' yardım modu.

Yerleşik '/ ??' ve '/? D' belge üreteci modları.

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: Bu benim projem ve bu nedenle bu cevap üçüncü bir tarafın ciro olarak görülmemelidir. Yazdığım her komut satırı tabanlı program için kullandığımı, açık kaynak olduğunu ve başkalarının bundan faydalanabileceğini umuyorum.


Sadece bir FYI, Rug.Cmd projesine (SSS'de belirtildiği gibi) bağlı olduğunuz konusunda küçük bir sorumluluk reddi koymanız gerekir: stackoverflow.com/faq#promotion - kaynak proje, ama yine de bir feragatname eklemek iyidir;) +1 bu arada ... oldukça iyi görünüyor.
Jason Down

Bunu işaret ettiğiniz için şerefe ve +1 için teşekkürler, bağlılığım hakkında daha açık olduğumdan emin olacağım.
Phill Tew

Endişeye gerek yok ... Bu tür bir şey için dışarıda bazı stickler var (onlardan biri değilim), bu yüzden insanlara bir kafa vermeyi seviyorum. Yine, genellikle açık kaynaklı projeler için bir sorun değildir. Çoğunlukla insanların (ücretli) ürünleri için önerileri spam göndermelerini engellemek.
Jason Down

3

Http://www.codeplex.com/commonlibrarynet adresinde bir komut satırı bağımsız değişken ayrıştırıcısı var


1. öznitelikleri kullanarak bağımsız değişkenleri ayrıştırabilir
2. açık çağrılar
3. birden çok bağımsız değişkenin tek satırı VEYA dize dizisi

Aşağıdaki gibi şeyleri işleyebilir:

- yapılandırma : Qa - startdate : $ { bugün } - bölge : 'New York' Settings01

Kullanımı çok kolay.


2

Bu, Novell Optionssınıfına dayanarak yazdığım bir işleyici .

Bu, bir while (input !="exit")stil döngüsü, örneğin bir FTP konsolu gibi etkileşimli bir konsol yürüten konsol uygulamalarına yöneliktir .

Örnek kullanım:

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

Ve kaynak:

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

2

Benim kişisel favorim http://www.codeproject.com/KB/recipes/plossum_commandline.aspx 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;
}

2

Son zamanlarda FubuCore Komut satırı ayrıştırma uygulamasına rastladım Gerçekten hoşuma gitti, nedenleri:

  • kullanımı kolay - bunun için bir belge bulamamam da, FubuCore çözümü, işlevsellik hakkında herhangi bir belgenin yapabileceğinden daha fazla konuşan güzel bir Birim Testleri içeren bir proje de sunuyor.
  • güzel bir nesne yönelimli bir tasarıma, kod tekrarı veya komut satırı uygulamalarımda kullandığım başka şeylere sahip değil
  • bildirim niteliğindedir: temel olarak Komutlar ve parametre setleri için sınıflar yazar ve çeşitli seçenekleri ayarlamak için niteliklerle süslersiniz (örn. ad, açıklama, zorunlu / isteğe bağlı)
  • kütüphane bu tanımlara dayanarak güzel bir Kullanım Grafiği bile yazdırıyor

Aşağıda bunun nasıl kullanılacağına dair basit bir örnek verilmiştir. Kullanımı göstermek için iki komut içeren basit bir yardımcı program yazdım: - add (listeye bir nesne ekler - bir nesne bir ad (dize), değer (int) ve bir boole bayrağı içerir) - list (listeler şu anda eklenen tüm nesneler)

Her şeyden önce, 'add' komutu için bir Command sınıfı yazdım:

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

Bu komut parametre olarak bir CommandInput örneği alır, bu yüzden bir sonraki tanımlayın:

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

Bir sonraki komut aşağıdaki gibi uygulanan 'list'tir:

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

'List' komutu hiçbir parametre almaz, bu yüzden bunun için bir NullInput sınıfı tanımladım:

public class NullInput { }

Şimdi kalan tek şey bunu Main () yönteminde bağlamaktır:

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

        var executor = new CommandExecutor(factory);

        executor.Execute(args);
    }

Program beklendiği gibi çalışır, herhangi bir komutun geçersiz olması durumunda doğru kullanım hakkında ipuçları yazdırır:

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

Ve 'add' komutu için örnek bir kullanım:

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


2

C # CLI yazdığım çok basit bir komut satırı argüman ayrıştırma kütüphanesidir. İyi belgelenmiş ve açık kaynaklıdır.


İyi belgelenmiş? Belgeler nerede?
Suhas

Dahili belgeler (örn. Kod tabanında) ve harici belgeler ( klasördeki Readme.mkddosyaya bakın Documentation) vardır.
Bernard

Tamam, aceleyle yorumladım. Belki projenizi github'a taşıyabilirsiniz ve belgeleriniz otomatik olarak ana sayfada görünmeye başlar.
Suhas


0

Açık kaynak kütüphanesi CSharpOptParse öneririm . Komut satırını ayrıştırır ve kullanıcı tanımlı bir .NET nesnesini komut satırı girdisiyle nemlendirir. Bir C # konsol uygulaması yazarken her zaman bu kütüphaneye dönüyorum.



0

Varsayılan bağımsız değişkenleri destekleyen komut satırı ayrıştırma için kullanımı kolay ad hoc sınıfı.

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"));
    }
}
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.