处理命令行参数时清理控制流[C#]

我正在处理一个基于命令行参数进行大量if…else分支的程序。这是C语言，但我确信它适用于java、C++等。这里是一般的概要：

if (args.Length == 0)
{
  //do something
}

if (args.Length > 0 && args.Length < 2)
    {
        Console.WriteLine("Only one argument specified. Need two arguments");
        return 0;

    }
            else if (args.Length > 0 && args.Length >= 2)
            {
                //Process file - Argument 1
                if(args[0].Trim() == PROCESS_OPTION_ONE
                    || args[0].Trim() == PROCESS_OPTION_TWO)
                {
                    //Process file - Argument 2
                    if(args[1].Trim() == PROCESS_CUSTOMER
                        || args[1].Trim() == PROCESS_ADMIN
                        || args[1].Trim() == PROCESS_MEMBER
                        || args[1].Trim() == PROCESS_GUEST
                        || args[1].Trim() == PROCESS_USER
                        )
                    {

if（args.Length==0）
{
//做点什么
}
如果（args.Length>0&&args.Length<2）
{
WriteLine（“只指定了一个参数，需要两个参数”）；
返回0；
}
else if（args.Length>0&&args.Length>=2）
{
//进程文件-参数1
if（args[0].Trim（）==进程选项
||args[0]。Trim（）==进程\u选项\u二）
{
//进程文件-参数2
if（args[1].Trim（）==处理客户
||args[1]。Trim（）==进程管理
||args[1]。Trim（）==进程成员
||args[1]。Trim（）==进程\u来宾
||args[1]。Trim（）==进程用户
)
{

---

因此，正如您所知，这有点混乱。是否有一两种设计模式最适合清理某些东西？也许是命令模式？谢谢您的建议和提示。

如果您已经返回，则不需要

其他

。这可能会减少大量嵌套。您还可以尝试使用切换我倾向于在arguments数组上使用switch语句，并在某个配置类中为每个预期参数设置属性，而不是使用一组嵌套的ifs。

似乎您希望的是一个格式非常特殊的参数字符串，而不是允许设置值，您可以尝试：

if(args[0].Trim() == PROCESS_OPTION_ONE || args[0].Trim() == PROCESS_OPTION_TWO) 
{ 
    //Process file - Argument 2
    switch(args[1].Trim()
    {
        case PROCESS_CUSTOMER, PROCESS_ADMIN, PROCESS_MEMBER, PROCESS_GUEST, PROCESS_USER:
            // Do stuff
            break;
        default:
            // Do other stuff
            break;
    }
}

我更喜欢的方法是

foreach(string arg in args)
{
    switch(arg)
    {
        case PROCESS_CUSTOMER:
            // Set property
            break;
        ...
        default:
            // Exception?
            break;
    }
}

注意：args.Length==1比args.Length>0快&args.Length<2。它的可读性也稍高。

停止嵌套

您可以像Joel所说的（+1）那样切换，也可以将逻辑分解为清晰的方法调用

if(args.Length <= 1)
{
  Console.WriteLine("Need 2 args kthx");
  return;
}
if(args.Length > 2)
{
  Console.WriteLine("More than 2 args don't know what do");
  return;
}

var arg1 = args[0].Trim();
var arg2 = args[1].Trim();

switch(arg1)
{
  case PROCESS_OPTION_ONE:
     ProcessOptionOne(arg2);
     break;
  case PROCESS_OPTION_TWO:
     ProcessOptionTwo(arg2);
     break;
  default:
     Console.WriteLine("First arg unknown I give up");
     return;
}

使方法尽可能简单，并将其分解得更长，将算法混淆为不同的方法调用，通过它们的名称，可以清楚地指示它们在做什么。

很久以前，我制作了自己的版本，用于命令行应用程序。我对其进行了自己的修改，比如让类继承但是代码中的正则表达式部分非常好，使这些命令行切换变得非常简单

private static void ProcessOptionTwo(string argumentTwo)
{
  if(argumentTwo == PROCESS_CUSTOMER ||
     argumentTwo  == PROCESS_ADMIN ||
     /* etc blah blah */
}