提问



构建带参数的控制台应用程序时,可以使用传递给Main(string[] args)的参数。


在过去,我只是简单地索引/循环该数组并完成一些正则表达式来提取值。但是,当命令变得更复杂时,解析会变得非常难看。


所以我对以下内容感兴趣:



  • 您使用的库

  • 您使用的模式



假设命令始终遵循通用标准,例如在此处回答。

最佳参考


我强烈建议使用NDesk.Options(Documentation)和/或Mono.Options(相同的API,不同的命名空间)。文件中的一个例子:[21] [22] [23] [24]


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

其它参考1


我非常喜欢Command Line Parser Library(http://commandline.codeplex.com/)。它有一种通过属性设置参数的非常简单和优雅的方式:[25]


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

其它参考2


WPF TestApi库附带了一个用于C#开发的最好的命令行解析器。我强烈建议从Ivo Manolov关于API的博客中查看:[26] [27]


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

其它参考3


请看http://github.com/mono/mono/tree/master/mcs/class/Mono.Options/[28]

其它参考4


看起来每个人都有自己的宠物命令行解析器,图我最好添加我的:)。


http://bizark.codeplex.com/[29]


该库包含一个命令行解析器,它将使用命令行中的值初始化类。它有很多功能(我已经建立了很多年)。[30]


从文件...... [31]


BizArk框架中的命令行解析具有以下主要功能:



  • 自动初始化:根据命令行参数自动设置类属性。

  • 默认属性:在不指定属性名称的情况下发送值。

  • 值转换:使用BizArk中也包含的强大ConvertEx类将值转换为正确的类型。

  • 布尔标志:可以通过简单地使用参数(例如,/b表示true,/b-表示false)或添加值true/false,yes/no等来指定标志。

  • 参数数组:只需在命令行名称后添加多个值即可设置定义为数组的属性。 Ex,/x 1 2 3将使用数组{1,2,3}填充x(假设x被定义为整数数组)。

  • 命令行别名:属性可以为其支持多个命令行别名。例如,帮助使用别名?。

  • 部分名称识别:您不需要拼出全名或别名,只需拼写就足以让解析器消除其他人的属性/别名的歧义。

  • 支持ClickOnce:即使将属性指定为ClickOnce部署的应用程序的URL中的查询字符串,也可以初始化属性。命令行初始化方法将检测它是否以ClickOnce运行,因此您的代码在使用时无需更改。

  • 自动创建/?帮助:这包括考虑到控制台宽度的漂亮格式。

  • 将命令行参数加载/保存到文件中:如果您要多次运行多个大型复杂的命令行参数,这将非常有用。


其它参考5


我不久前写了一个C#命令行参数解析器。它位于:http://www.codeplex.com/CommandLineArguments [32]

其它参考6


CLAP(命令行参数解析器)具有可用的API,并且记录得非常好。你创建了一个方法,注释参数。 https://github.com/adrianaisemberg/CLAP[33][34]

其它参考7


这个问题有很多解决方案。为了完整性并提供备选,如果有人愿意我在谷歌代码库中添加两个有用的类的答案。[35]


第一个是ArgumentList,它只负责解析命令行参数。它收集由开关/x:y或-x=y定义的名称 - 值对,并且还收集未命名条目的列表。这里讨论了它的基本用法,在这里查看课程。[36] [37]


第二部分是CommandInterpreter,它从.Net类中创建一个功能齐全的命令行应用程序。举个例子:[38]


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:string value



它就像你需要的那样简单或复杂。你可以查看源代码,查看帮助或下载二进制文件。[39] [40] [41]

其它参考8


我喜欢那个,因为你可以为论证定义规则,是否需要,...... [42]


或者如果你是一个Unix家伙,那么你可能不喜欢GNU Getopt .NET端口。[43]

其它参考9


你可能会喜欢我的一个Rug.Cmd [44]


易于使用和可扩展的命令行参数解析器。句柄:Bool,加/减,字符串,字符串列表,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);
        }
    }
}


编辑:这是我的项目,因此这个答案不应被视为第三方的认可。也就是说,我确实将它用于我编写的每个基于命令行的程序,它是开源的,我希望其他人可以从中受益。

其它参考10


在http://www.codeplex.com/commonlibrarynet上有一个命令行参数解析器[[]] [[]]


它可以使用
解析参数
1.属性

2.显式调用

3.单行多个参数或字符串数​​组


它可以处理以下内容:


- 配置:Qa - startdate :$ {今天} - 区域:纽约设置01


它非常容易使用。

其它参考11


这是我根据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;
    }
}

其它参考12


我个人最喜欢的是Peter Palotas的http://www.codeproject.com/KB/recipes/plossum_commandline.aspx:[46]


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

其它参考13


我最近遇到了FubuCore Command line解析实现我真的很喜欢它,原因是:



  • 它易于使用 - 虽然我无法找到它的文档,但是FubuCore解决方案还提供了一个包含一组很好的单元测试的项目,它比任何文档更能说明功能

  • 它有一个很好的面向对象设计,没有代码重复或我曾经在我的命令行解析应用程序中的其他东西

  • 它是声明性的:你基本上为命令和参数集编写类,并用属性装饰它们以设置各种选项(例如名称,描述,强制/可选)

  • 该库甚至可以根据这些定义打印出一个很好的用法图



下面是一个如何使用它的简单示例。为了说明用法,我编写了一个包含两个命令的简单实用程序:
- 添加(将对象添加到列表中 - 对象由名称(字符串),值(int)和布尔标志组成)
- 列表(列出所有当前添加的对象)


首先,我为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
  -------------------------------------

其它参考14


Powershell Commandlets。


由PowerShell根据命令行开关上指定的属性进行解析,支持验证,参数集,流水线操作,错误报告,帮助以及最好的返回.NET对象,以便在其他命令行开关中使用。


几个链接我发现有用的入门:



  • 快速入门教程

  • MSDN编程指南

  • MSDN上的命名空间参考


其它参考15


C#CLI是我编写的一个非常简单的命令行参数解析库。它有充分的记录和开源。[47] [48] [49] [50]

其它参考16


Genghis Command Line Parser可能有点过时,但它功能齐全,对我来说效果很好。[51]

其它参考17


我会建议开源库CSharpOptParse。它解析命令行并使用命令行输入来保护用户定义的.NET对象。在编写C#控制台应用程序时,我总是转向这个库。[52]

其它参考18


请使用apache commons cli API的.net端口。这很好用。


http://sourceforge.net/projects/dotnetcli/[53]


以及概念和介绍的原始API


http://commons.apache.org/cli/[54]

其它参考19


一个非常简单易用的ad hoc类,用于命令行解析,支持默认参数。


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