C# 超花哨的 LINQiness

Question

我正在尝试编写一种动态排序的命令行处理器，其中我有一个字典，其中键是可能的参数，成员是一个操作，其中字符串是命令行上传递的参数之间的文本。希望能够通过添加 params 数组并将操作写入字典来添加参数。

是的，我意识到这是为了简化维护而使实施变得过于复杂的毫无意义的做法。主要是想给自己施加压力，学习更多 linq。

这是我的字典：

    private static Dictionary<string[], Action<string>> _commandLineParametersProcessor = new Dictionary<string[], Action<string>>()
{
    {
        new string[] {"-l", "--l", "-log", "--log"},
        (logFile) =>  
            {
                _blaBla.LogFilePath = logFile;
            }
    },
    {
        new string[] { "-s", "--s", "-server", "--server" },
        (server) =>  
            {
                ExecuteSomething(server);
                _blaBla.Server = server;
            }
    }
};

采用 string[] args 的最优雅的机制是什么，而不仅仅是关联属于任何字典键数组的成员，而是 Aggregate((x,y) => string.Format("{0} {1}", x, y)) 元素序列（认为 TakeWhile() 以某种方式适合这里）位于将在任何键数组中 Contain()ed 的 args[] 成员之间，并将它们传递到相应键的值成员的操作。

我们都已经无数次编写过这些小型命令行处理器，虽然显然简单的循环和切换总是绰绰有余，但正如我所说，这又是一次试图强调我的 linq 技能的练习。所以请不要抱怨我过度设计，这部分是显而易见的。

更新： 为了使这可能更容易一点，这里有一种非 linq 的方式来做我正在寻找的事情（可能不完美，这只是即兴发挥）：

Action<string> currentAction;
string currentActionParameter;
for(int i = 0; i < e.Args.Length; i++)
{
    bool isParameterSwitch = _commandLineParametersProcessor.Keys.Any((parameterChoices) => parameterChoices.Contains(e.Args[i]));

    if (isParameterSwitch)
    {
        if (!string.IsNullOrEmpty(currentActionParameter) && currentAction != null)
        {
            currentAction(currentActionParameter);

            currentAction = null;
            currentActionParameter = "";
        }
        currentAction = _commandLineParametersProcessor[_commandLineParametersProcessor.Keys.Single((parameterChoices) => parameterChoices.Contains(e.Args[i]))];
    }
    else
    {
        currentActionParameter = string.Format("{0} {1}", currentActionParameter, e.Args[i]);
    }
}

这并不是一个完全糟糕的方法，我只是想知道是否有人可以使用 linq 或其他方式稍微简化它，尽管这可能是我猜的最简单的形式。

Answer 1

借用 Adam Robinson 答案的一半（顺便说一句+1），但意识到字典永远不会通过键访问，并且您只想运行操作而不是构建字符串...

var inputCommands = args
    .Select((value, idx) => new { Value = value, Group = idx / 2 })
    .GroupBy(x => x.Group) 
    .Select(g => new  
    {  
      Command = g.First().Value,  
      Argument = g.Last().Value  
    }).ToList();

inputCommands.ForEach(x => 
{
  Action<string> theAction = 
  (
    from kvp in commands
    where kvp.Key.Contains(x.Command)
    select kvp.Value
  ).FirstOrDefault();
  if (theAction != null)
  {
    theAction(x.Argument);
  }
}

kvp.Key.Contains< /code> 确实违背了字典的全部要点。我将其重新设计为 Dictionary>。然后你可以说

inputCommands.ForEach(x => 
{
  if (commands.ContainsKey(x.Command))
  {
    commands[x.Command](x.Argument);
  }
}

PS：我记得我写过的 C# 代码比这多得多。

---

我必须承认您可能想要收集操作，而不是运行它们。这是该代码：

var todo =
(
  from x in inputCommands
  let theAction = 
  (
    from kvp in commands
    where kvp.Key.Contains(x.Command)
    select kvp.Value
  ).FirstOrDefault()
  where theAction != null
  select new { TheAction = theAction, Argument = x.Argument }
).ToList();

Answer 2

假设您知道每个命令都有一个相应的参数（因此“args”将始终采用以下格式

cmd arg (repeated)

您可以做一些像这样荒谬的事情...

var output = args.Select((value, idx) => new { Value = value, Group = idx / 2 })
            .GroupBy(x => x.Group)
            .Select(g => new 
             { 
                 Command = commands.FirstOrDefault(kvp => 
                    kvp.Key.Contains(g.First().Value)).Value, 
                 Argument = g.Last().Value 
             })
            .Where(c => c.Command != null)
            .Aggregate(
                new StringBuilder(), 
                (builder, value) => 
                { 
                    builder.AppendLine(value.Command(value.Argument)); 
                    return builder; 
                }).ToString();

但坦率地说，这是我记得曾经写过的 C# 中最迟钝的部分，这并不是自学 LINQ 的好方法，但是它会按照您的要求

编辑

刚刚意识到（感谢 David B）您的密钥是一个 string[] 。 ，而不仅仅是一个字符串，所以我添加了一些甚至更迟钝的代码来处理这个问题。