C #에서 명령 줄 인수를 구문 분석하는 가장 좋은 방법은 무엇입니까? [닫은]


731

매개 변수를 사용하는 콘솔 응용 프로그램을 빌드 할 때에 전달 된 인수를 사용할 수 있습니다 Main(string[] args).

과거에는 단순히 해당 배열을 인덱싱 / 루프하고 몇 가지 정규 표현식을 수행하여 값을 추출했습니다. 그러나 명령이 더 복잡해지면 구문 분석이 매우 어려워 질 수 있습니다.

그래서 나는 관심이 있습니다 :

  • 사용하는 라이브러리
  • 사용하는 패턴

명령이 항상 여기에 답변 된 것과 같은 공통 표준을 준수한다고 가정 하십시오 .


이전 논의, split-string-include-command-line-parameters-in-string-in-c # 에 대한 답변이있을 수 있습니다.
기멜

1
죄송합니다. 주제가 약간 다릅니다. 그러나 "응용 프로그램 설정"을 사용하여 응용 프로그램에 인수를 전달합니다. 사용하기 쉽고 인수 / 파일 구문 분석을 작성할 필요가 없으며 추가 라이브러리가 필요하지 않습니다. msdn.microsoft.com/ko-kr/library/aa730869(VS.80).aspx
Steve

44
@call me Steve : 명령 줄 인수의 요점은 호출마다 다를 수 있다는 것입니다. 응용 프로그램 설정에서는 어떻게해야합니까?
reinierpost

답변:


324

NDesk.Options ( Documentation ) 및 / 또는 Mono.Options (동일한 API, 다른 네임 스페이스)를 사용하는 것이 좋습니다 . 설명서 :

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는 훌륭하지만 둘 이상의 고유 한 명령을 사용하는 콘솔 앱을 실제로 지원하지는 않습니다. 원하는 경우 NDesk.Options에 빌드 된 ManyConsole을 사용해보십시오. nuget.org/List/Packages/ManyConsole
Frank Schwieterman

5
여러 개의 고유 한 명령이있는 하나의 앱이있는 경우 OptionSet을 "계층화"합니다. "전역"OptionSet이있는 mdoc ( docs.go-mono.com/index.aspx?link=man%3amdoc%281%29 )을 가져 가십시오 ( github.com/mono/mono/blob/master/mcs/tools/ mdoc /… )-명령 별 OptionSet에 위임 (예 : github.com/mono/mono/blob/master/mcs/tools/mdoc/… )
jonp

3
NDesk는 나를 위해 일하지 않습니다. 정수 인수는 읽을 수 있지만 문자열은 읽을 수 없습니다. 변수는 인수 값 (예 : 'serverName', 'ApplicationName') 대신 인수 (예 : 's', 'a'등)를 계속받습니다. 대신 'Command Line Parser Library'를 사용하십시오. 알았어
Jay

2
@AshleyHenderson 우선, 작고 유연합니다. 대부분의 솔루션을 선택 명명 된 인수 (즉, 같이 할 수 없어에서만 작동 git checkout master), 또는 인수 (즉, 지원하지 않는 유연한 아니다 --foo 123= --foo=123= -f 123= -f=123또한 -v -h= -vh).
Wernight

1
@FrankSchwieterman은 자체 답변이어야합니다. 그리고 팁에 감사드립니다. ManyConsole은 정말 대접입니다.
quentin-starin

197

나는 커맨드 라인 파서 라이브러리 ( http://commandline.codeplex.com/ )를 정말 좋아합니다 . 속성을 통해 매개 변수를 설정하는 매우 간단하고 우아한 방법이 있습니다.

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
이것은 내가 정착 한 도서관입니다. 몇 년 동안 유지 관리해야하는 대기업을위한 응용 프로그램을 작성 중입니다.이 라이브러리는 2005 년 이후 지속적으로 업데이트되어 인기가있는 것으로 보이며 C # 커뮤니티에서 활동하는 사람들이 작성했으며 BSD 스타일로 라이센스가 부여 된 경우입니다. 지원은 사라집니다.
Charles Burns

나는 또한 이것을 추천한다. 내 유일한 문제는 : 허용 된 인수 조합을 지정하면 (예 : 이동 인수에 소스 및 대상 인수가 있어야하는 경우) 속성과 관련이 있을 수 있습니다. 하지만 당신은 아마 더 나은 오프 별도의 인수 검증 로직을 수행
린든 화이트

1
나는 옵션 클래스를 좋아한다. 명명되지 않은 매개 변수와 플래그 --recursive도 지원하는 것 같습니다 .
Wernight

2
방금 테스트했으며 몇 분 안에 응용 프로그램 옵션을 구현했습니다. 라이브러리를 사용하는 것은 매우 간단합니다.
Trismegistos

3
이 라이브러리는 저에게 매우 제한적이라는 것을 알았습니다. 독점 세트가 필요한 경우 각 세트에 필요한 옵션을 정의 할 수 없으므로 수동으로 확인해야합니다. 명명되지 않은 값에 대한 최소 요구 사항을 정의 할 수 없으므로 수동으로 확인해야합니다. 도움말 화면 빌더도 전혀 융통성이 없습니다. 라이브러리의 동작이 기본 요구 사항에 맞지 않으면 거의 변경하지 않아도됩니다.
Sergey Kostrukov

50

WPF TestApi 라이브러리는 C #을 개발을위한 좋은 명령 줄 파서 중 하나와 함께 제공됩니다. API에 대한 Ivo Manolov의 블로그 에서 살펴 보는 것이 좋습니다 .

// 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. 명령 줄 구문 분석은 공급 업체의 지원이 라운드 방식으로 제공 되더라도 타사 도구를 통하지 않고 공급 업체 (예 : Microsoft)가 제공해야하는 것입니다.
Joel Coehoorn

2
즉, 받아 들인 대답 (모노)이 차선책입니다.
Joel Coehoorn

6
@Joel, 명령 줄 구문 분석이 공급 업체의 중요한 부분은 무엇입니까? 당신의 이유는 무엇입니까?
greenoldman

3
@marcias : 나는 그가 아마도 상자 밖으로 나왔을 것입니다 ... 많은 것들처럼 :)
user7116

도서관은 크다! 내가 필요한 것보다 훨씬 더 포함 ...
Riri

24

2
NDesk 옵션에는 매우 멋진 API가 있습니다
user35149

2
나는 NDesk에 대해 또 다른 투표를 추가 할 것입니다.
Terence

1
Mono.GetOptions는 매우 오래되었습니다. NDesk.Options는 훨씬 더 좋습니다 (또는 원하는 경우 동일한 클래스 인 Mono.Options : anonsvn.mono-project.com/source/trunk/mcs/class/Mono.Options/… )
Matt Enright

7
@Adam Oren : 제 대답은 1 년 1 개월입니다! 모노 트렁크의 구조가 리팩터링되었습니다. 이 코드는 이제 anonsvn.mono-project.com/viewvc/branches/mono-2-2/mcs/class/…에
abatishchev

6
@Tormod : Mono.Options가 아닌 더 이상 사용되지 않는 Mono.GetOptions입니다. Mono. 옵션은 계속 유지됩니다.
jonp

14

모두가 자신의 애완 동물 명령 줄 파서를 가지고있는 것처럼 보입니다.

http://bizark.codeplex.com/

이 라이브러리에는 명령 줄 의 값으로 클래스를 초기화 하는 명령 줄 파서 가 포함되어 있습니다 . 그것은 많은 기능을 가지고 있습니다 (수년 동안 그것을 구축해 왔습니다).

로부터 문서 ...

BizArk 프레임 워크의 명령 줄 구문 분석에는 다음과 같은 주요 기능이 있습니다.

  • 자동 초기화 : 클래스 속성은 명령 줄 인수를 기반으로 자동 설정됩니다.
  • 기본 속성 : 속성 이름을 지정하지 않고 값을 보냅니다.
  • 값 변환 : BizArk에 포함 된 강력한 ConvertEx 클래스를 사용하여 값을 적절한 유형으로 변환합니다.
  • 부울 플래그 : 단순히 인수 (예 : true, / b, false / b-)를 사용하거나 true / false, yes / no 등의 값을 추가하여 플래그를 지정할 수 있습니다.
  • 인수 배열 : 명령 줄 이름 뒤에 여러 값을 추가하면 배열로 정의 된 속성을 설정할 수 있습니다. 예를 들어, / x 1 2 3은 x를 {1, 2, 3} 배열로 채 웁니다 (x가 정수 배열로 정의되었다고 가정).
  • 명령 줄 별칭 : 속성은 여러 명령 줄 별칭을 지원할 수 있습니다. 예를 들어, 도움말은?를 사용합니다.
  • 부분 이름 인식 : 전체 이름이나 별칭을 철자 할 필요는 없습니다. 파서가 속성 / 별칭을 다른 속성과 명확하게 구분할 수있을 정도로만 철자를 입력하십시오.
  • ClickOnce 지원 : ClickOnce 배포 응용 프로그램의 URL에서 쿼리 문자열로 지정된 경우에도 속성을 초기화 할 수 있습니다. 명령 줄 초기화 방법은 ClickOnce로 실행 중인지 여부를 감지하므로 사용시 코드를 변경할 필요가 없습니다.
  • 자동으로 /? 도움말 : 콘솔 너비를 고려한 멋진 형식이 포함되어 있습니다.
  • 명령 줄 인수를 파일에로드 / 저장 : 여러 번 실행하려는 크고 복잡한 명령 줄 인수가 여러 개인 경우에 특히 유용합니다.

2
BizArk의 명령 줄 파서는 다른 것보다 훨씬 쉽고 유창합니다. 추천!
보리스 Modylevsky


9

CLAP (명령 줄 인수 파서)에는 유용한 API가 있으며 훌륭하게 문서화되어 있습니다. 매개 변수에 주석을 달아 메소드를 작성합니다. https://github.com/adrianaisemberg/CLAP


2
사용이 매우 간단하고 웹 사이트가 흔들립니다. 그러나 그들의 구문은 매우 직관적이지 않습니다 : myapp myverb -argname argvalue(필수 -argname) 또는 myapp -help(보통 --help).
Wernight

@Wernight Verb에서 IsDefault 매개 변수를 사용하면 생략 할 수 있습니다. 위치 매개 변수에 대한 지원을 찾지 못했지만 명령 줄을 직접 구문 분석 할 때 위치 매개 변수 만 사용했습니다. 명명 된 인수와 값 IMHO를 사용하는 것이 훨씬 더 명확합니다.
Loudenvier

5

이 문제에 대한 수많은 해결책이 있습니다. 완전성을 원하고 누군가가 원하는 경우 대안을 제공하기 위해 Google 코드 라이브러리 에 두 가지 유용한 클래스에 대한 답변을 추가하고 있습니다 .

첫 번째는 ArgumentList이며 명령 행 매개 변수 구문 분석 만 담당합니다. 스위치 '/ x : y'또는 '-x = y'에 의해 정의 된 이름-값 쌍을 수집하고 '명명되지 않은'항목의 목록도 수집합니다. 기본적인 사용법은 여기 에서 설명 합니다 . 여기에서 클래스를보십시오 .

두 번째 부분은 CommandInterpreter 로 .Net 클래스에서 완전한 기능을 갖춘 명령 줄 응용 프로그램을 만듭니다. 예로서:

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

위의 예제 코드를 사용하면 다음을 실행할 수 있습니다.

Program.exe DoSomething "문자열 값"5

-또는-

Program.exe dosomething / ivalue = 5 -svalue : "문자열 값"

간단하거나 필요에 따라 복잡합니다. 당신은 수있는 소스 코드를 검토 , 도움을 보거나 , 또는 바이너리를 다운로드 .



4

당신은 내 하나의 러그를 좋아할 것입니다.

사용하기 쉽고 확장 가능한 명령 줄 인수 파서. 처리 : 부울, 플러스 / 마이너스, 문자열, 문자열 목록, CSV, 열거.

'/?'내장 도움말 모드.

'/ ??'내장 및 '/? 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);
        }
    }
}

편집 : 이것은 내 프로젝트 이므로이 답변은 타사의 추천으로 보아서는 안됩니다. 그것은 내가 작성한 모든 명령 줄 기반 프로그램에 사용한다고 말했지만 오픈 소스이며 다른 사람들이 혜택을 볼 수 있기를 바랍니다.


그냥 참고로, 당신은 당신이 (자주 묻는 질문에서 언급 한대로) Rug.Cmd 프로젝트와 제휴되어 조금 부인 넣어 것을 : stackoverflow.com/faq#promotion - 당신은 개방을 홍보하기 때문에 아니 큰 거래를 소스 프로젝트이지만, 면책 조항을 추가하는 것이 좋습니다.) +1 그런데 ... 꽤 잘 보입니다.
Jason Down

이를 지적하고 +1 해 주셔서 감사합니다. 저는 제휴에 대해 더 명확하게 설명하겠습니다.
Phill Tew

걱정하지 마십시오.이 유형의 물건에 대한 몇 가지 stickler가 있습니다 (나는 그들 중 하나가 아닙니다). 그래서 사람들에게 머리를주는 것을 좋아합니다. 다시 한 번, 오픈 소스 프로젝트에는 일반적으로 문제가되지 않습니다. 사람들이 (유료) 제품에 대한 스팸 추천을하지 못하게하는 것이 대부분입니다.
Jason Down

3

http://www.codeplex.com/commonlibrarynet에 명령 행 인수 구문 분석기가 있습니다 .


1을 사용하여 인수를 구문 분석 할 수 있습니다 .
2. 명시 적 호출
3. 여러 인수의 단일 행 또는 문자열 배열

다음과 같은 것을 처리 할 수 ​​있습니다.

- 설정 : Qa- 시작일 : $ { 오늘 }- 지역 : '뉴욕'설정 01

사용하기 매우 쉽습니다.


2

이것은 Novell Options클래스를 기반으로 작성한 처리기 입니다.

이것은 while (input !="exit")FTP 루프와 같은 대화식 콘솔 인 스타일 루프 를 실행하는 콘솔 응용 프로그램을 대상 으로합니다.

사용법 예 :

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

그리고 출처 :

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

내가 가장 좋아하는 것은 Peter Palotas의 http://www.codeproject.com/KB/recipes/plossum_commandline.aspx입니다 .

[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

최근에 FubuCore Command line 구문 분석 구현이 마음에 들었습니다. 그 이유는 다음과 같습니다.

  • 사용하기 쉽습니다-설명서를 찾을 수는 없지만 FubuCore 솔루션은 문서보다 기능에 대해 더 잘 설명하는 단위 테스트 세트를 포함하는 프로젝트를 제공합니다.
  • 멋진 객체 지향 디자인, 코드 반복 또는 명령 줄 구문 분석 응용 프로그램에서 사용했던 것과 같은 것들이 있습니다.
  • 선언적입니다. 기본적으로 명령 및 매개 변수 집합에 대한 클래스를 작성하고 다양한 옵션 (예 : 이름, 설명, 필수 / 선택 사항)을 설정하는 특성으로 장식합니다.
  • 라이브러리는 이러한 정의를 기반으로 멋진 사용 그래프를 인쇄합니다.

아래는 이것을 사용하는 간단한 예입니다. 사용법을 설명하기 위해 두 가지 명령이있는 간단한 유틸리티를 작성했습니다. 현재 추가 된 모든 객체)

먼저 'add'명령에 대한 Command 클래스를 작성했습니다.

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

이 명령은 CommandInput 인스턴스를 매개 변수로 사용하므로 다음을 정의합니다.

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

다음 명령은 'list'이며 다음과 같이 구현됩니다.

[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'명령은 매개 변수를 사용하지 않으므로 NullInput 클래스를 정의했습니다.

public class NullInput { }

이제 남은 것은 Main () 메소드에서 이것을 다음과 같이 연결하는 것입니다.

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

        var executor = new CommandExecutor(factory);

        executor.Execute(args);
    }

명령이 유효하지 않은 경우 올바른 사용법에 대한 힌트를 인쇄하여 프로그램이 예상대로 작동합니다.

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

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


2

C # CLI 는 내가 작성한 매우 간단한 명령 줄 인수 구문 분석 라이브러리입니다. 잘 문서화되고 오픈 소스입니다.


잘 기록 된? 문서는 어디에 있습니까?
Suhas

내부 문서 (예 : 코드베이스)와 외부 문서가 있습니다 ( 폴더 의 Readme.mkd파일 참조 Documentation).
Bernard

좋아, 나는 성급하게 논평했다. 프로젝트를 github으로 옮기면 문서가 자동으로 홈 페이지에 나타나기 시작할 수 있습니다.
Suhas


0

오픈 소스 라이브러리 CSharpOptParse를 제안합니다 . 명령 행을 구문 분석하고 명령 행 입력으로 사용자 정의 .NET 오브젝트를 수화합니다. C # 콘솔 응용 프로그램을 작성할 때는 항상이 라이브러리를 사용합니다.



0

기본 인수를 지원하는 명령 줄 구문 분석을위한 매우 간단한 사용하기 쉬운 임시 클래스입니다.

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"));
    }
}
당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.