命令行（类csc编译器）解析

Question

我正在寻找一个算法/库来解析此命令行：

var cmd = "foo /option:value /option2:valueof /etc:.. baa /t:4 etc xd";

to：

foo => { "option", "value" },
       { "option2", "valueof" },
       {"etc", ".."},
baa => {"t", "4"},
etc => {"xd", ""},

我尝试在“纯模式”（类似C）中仅使用if和for。但是使用正则表达式或 linq 的解决方案非常受欢迎。

我的代码（不起作用）：

var cmd = "foo /option:value /option2:valueof /etc:.. baa /t:4 etc xd";
            var keys = new Dictionary<string, Dictionary<string,string>>();

            for (int pos = 0, len = cmd.Length; pos < len; pos++)
            {
                StringBuilder buffer = new StringBuilder();
                char c = cmd[pos];

                if (c == '/') 
                {
                    StringBuilder optionName = new StringBuilder();
                    StringBuilder optionValue = new StringBuilder();

                    do
                    {
                        c = cmd[pos++];

                        if (c == ':')
                        {
                            do
                            {
                                c = cmd[pos++];
                                optionValue.Append(c);

                            } while (c != '/' || c != ' ');
                        }
                        else
                        {
                            optionName.Append(c);
                        }

                    } while (c != ' ');

                    keys.Add(buffer.ToString(),
                        new Dictionary<string, string>
                        {
                            {optionName.ToString(), optionValue.ToString()}
                        });
                }
            }

它给出了一个索引超出了数组的范围。

提前致谢。

Answer 1

当然有一些库可以处理命令行解析（SO 推荐 NDesk ，但我个人没有使用过）。

我会使用 字符串。 Split() 逐个字符地迭代字符串。

            var tokenCmd = cmd.Split(' ');
            string currentKey = "";

            foreach (var token in tokenCmd)
            {
                if ((char.IsLetterOrDigit(token[0])) &&
                    (!keys.ContainsKey(currentKey)) ||
                    (keys[currentKey].Any()))
                {
                    currentKey = token;
                    keys.Add(currentKey,
                             new Dictionary<string, string>());
                }
                else
                {
                    var splitToken = new[] { token, "" };

                    if (token.Contains(':'))
                    {
                        splitToken = token
                            .Replace("/", "")
                            .Split(':');
                    }

                    keys[currentKey].Add(splitToken[0],
                                         splitToken[1]);
                }
            }

Answer 2

更改：

} while (c != '/' || c != ' '); 

至：

} while (c != '/' && c != ' '); 

Answer 3

如果您可以保留将命令行分开（它们在您的输入变量中一起压缩）并保留参数传入的 string[] 对象类型，那么我认为这就是您正在寻找的机器人：

static void Main(string[] args)
{
    Hashtable parsedArgs = new Hashtable();
    args.ToList().ForEach(x => {
        int dpos = x.IndexOf(":");
        if (dpos > -1)
            parsedArgs[x.Substring(1, dpos - 1)] = x.Substring(dpos + 1);
        else
            parsedArgs[x.Substring(1)] = true;
    });
}

编辑：修订将 Linq 转换为哈希表，如下所示。哈希表比看起来更优雅（代码更少）的 KeyValuePair<> 更容易使用。在我原来的答案中。