简化C#代码中的if-else梯形图

编辑：为了避免这种情况，我对特定的编程实践或编码方式更感兴趣。但任何建议都是受欢迎的

我编写了这个丑陋的代码来执行某些任务：

switch(arg[0])
{ 
    case "a"
    {
        foreach(var c in obja)
        {
            if(c.entry == 'a')
            {
                if (Independent_condition_1)
                {
                    // do logging
                    continue;
                }
                if (Independent_condition_2)
                {
                    // do logging
                    continue;
                }
                // Do something if above two conditions are false
            }
            else
            {
                if (Independent_condition_3)
                {
                    // do logging
                    continue;
                }
                if (Independent_condition_4)
                {
                    // do logging
                    continue;
                }
                // do something if above 2 conditions are false.
            }
        }
        break;
    }
    case "b"
    {
        // similar if else ladder
    }   
}

---

问题是代码看起来很难看，很难阅读。为了简化代码，我将if-else中的大部分内容移到了函数中。这种长嵌套if-else的替代方案是什么？

您可以创建许多私有方法，用于做出决策或处理单个案例，或者将单个案例的逻辑封装在单独的类中。后者使测试更容易，而前者只是防止代码变得笨拙

我倾向于在单个方法中使圈复杂度不超过5（如果我能帮助的话…）

使用私有方法的代码示例：

 private void method(string[] arg)
    {
        switch (arg[0])
        {
            case "a":
                HandleCaseA();
                break;

            case "b":
                HandleCaseB();
                break;
            default:
                throw new ArgumentException("arg");
        }
    }



    private void HandleCaseA()
    {
        foreach (var c in obja)
        {
            if (c.entry == 'a')
                HandleSubCaseA();
            else if (!(Independent_condition_3 || Independent_condition_4)
            HandleSubCaseAWithConditions3And4();

        }           
    }

    private void HandleSubCaseA()
    {
        if (!(Independent_condition_1 || Independent_condition_2))
            {
                // Do something
            }
        }
    }

    private void HandleCaseB ()
    {
        //Do stuff
    }

    private void HandleSubCaseAWithConditions3And4()
    {
        //Do stuff
    }
}

---

您可以创建许多私有方法来做出决策或处理单个案例，或者将单个案例的逻辑封装在单独的类中。后者使测试更容易，而前者只是防止代码变得笨拙

我倾向于在单个方法中使圈复杂度不超过5（如果我能帮助的话…）

使用私有方法的代码示例：

 private void method(string[] arg)
    {
        switch (arg[0])
        {
            case "a":
                HandleCaseA();
                break;

            case "b":
                HandleCaseB();
                break;
            default:
                throw new ArgumentException("arg");
        }
    }



    private void HandleCaseA()
    {
        foreach (var c in obja)
        {
            if (c.entry == 'a')
                HandleSubCaseA();
            else if (!(Independent_condition_3 || Independent_condition_4)
            HandleSubCaseAWithConditions3And4();

        }           
    }

    private void HandleSubCaseA()
    {
        if (!(Independent_condition_1 || Independent_condition_2))
            {
                // Do something
            }
        }
    }

    private void HandleCaseB ()
    {
        //Do stuff
    }

    private void HandleSubCaseAWithConditions3And4()
    {
        //Do stuff
    }
}

---

您可以创建许多私有方法来做出决策或处理单个案例，或者将单个案例的逻辑封装在单独的类中。后者使测试更容易，而前者只是防止代码变得笨拙

我倾向于在单个方法中使圈复杂度不超过5（如果我能帮助的话…）

使用私有方法的代码示例：

 private void method(string[] arg)
    {
        switch (arg[0])
        {
            case "a":
                HandleCaseA();
                break;

            case "b":
                HandleCaseB();
                break;
            default:
                throw new ArgumentException("arg");
        }
    }



    private void HandleCaseA()
    {
        foreach (var c in obja)
        {
            if (c.entry == 'a')
                HandleSubCaseA();
            else if (!(Independent_condition_3 || Independent_condition_4)
            HandleSubCaseAWithConditions3And4();

        }           
    }

    private void HandleSubCaseA()
    {
        if (!(Independent_condition_1 || Independent_condition_2))
            {
                // Do something
            }
        }
    }

    private void HandleCaseB ()
    {
        //Do stuff
    }

    private void HandleSubCaseAWithConditions3And4()
    {
        //Do stuff
    }
}

---

您可以创建许多私有方法来做出决策或处理单个案例，或者将单个案例的逻辑封装在单独的类中。后者使测试更容易，而前者只是防止代码变得笨拙

我倾向于在单个方法中使圈复杂度不超过5（如果我能帮助的话…）

使用私有方法的代码示例：

 private void method(string[] arg)
    {
        switch (arg[0])
        {
            case "a":
                HandleCaseA();
                break;

            case "b":
                HandleCaseB();
                break;
            default:
                throw new ArgumentException("arg");
        }
    }



    private void HandleCaseA()
    {
        foreach (var c in obja)
        {
            if (c.entry == 'a')
                HandleSubCaseA();
            else if (!(Independent_condition_3 || Independent_condition_4)
            HandleSubCaseAWithConditions3And4();

        }           
    }

    private void HandleSubCaseA()
    {
        if (!(Independent_condition_1 || Independent_condition_2))
            {
                // Do something
            }
        }
    }

    private void HandleCaseB ()
    {
        //Do stuff
    }

    private void HandleSubCaseAWithConditions3And4()
    {
        //Do stuff
    }
}

---

您可以在方法中组合条件和处理。如果在编写时条件是独立的，则没有开关，因此必须将工作划分为可读性更强（或可读性更低）的块，如下所示：

if (c.entry == 'a')
{
     ProcessEntryA(c);
} else ...
     // etc
}

---

您可以在方法中组合条件和处理。如果在编写时条件是独立的，则没有开关，因此必须将工作划分为可读性更强（或可读性更低）的块，如下所示：

if (c.entry == 'a')
{
     ProcessEntryA(c);
} else ...
     // etc
}

---

您可以在方法中组合条件和处理。如果在编写时条件是独立的，则没有开关，因此必须将工作划分为可读性更强（或可读性更低）的块，如下所示：

if (c.entry == 'a')
{
     ProcessEntryA(c);
} else ...
     // etc
}

---

您可以在方法中组合条件和处理。如果在编写时条件是独立的，则没有开关，因此必须将工作划分为可读性更强（或可读性更低）的块，如下所示：

if (c.entry == 'a')
{
     ProcessEntryA(c);
} else ...
     // etc
}

---

首先，代码中有很多不必要的分支。我会合并并否定它们。这将使代码更具可读性

switch(arg[0])
{ 
 case "a"
 {
  foreach(var c in obja)
  {
     if(c.entry == 'a')
     {
        if(!(Independent_condition_1 || Independent_condition_2))
        {
          // Do something
        }
      }
     else
      {
       if(!(Independent_condition_3 || Independent_condition_4)
        {
         // do something
        }
       }
     break;
      }
 case "b"
  {
  //similar if else ladder
  }   
}

接下来我会把它分解成不同的方法。通过将方法命名为适合您的领域的合理方法，您将使代码更具可读性。这也意味着当您进行更改时，您只需考虑您正在处理的小部分，而不是整个复杂的方法

switch(arg[0])
{ 
 case "a"
 {
  foreach(var c in obja)
  {
     newMethod(c);
     break;
      }
 case "b"
  {
  //similar if else ladder
  }   
}

void newMethod(str c) {
  if(c.entry == 'a')
     {
        if(!(Independent_condition_1 || Independent_condition_2))
        {
          // Do something
        }
      }
     else
      {
       if(!(Independent_condition_3 || Independent_condition_4)
        {
         // do something
        }
       }
}

---

然后，您可以继续将其分解为较小的、命名良好的方法，直到更容易理解为止。

首先，您的代码中有许多不必要的分支。我会合并并否定它们。这将使代码更具可读性

switch(arg[0])
{ 
 case "a"
 {
  foreach(var c in obja)
  {
     if(c.entry == 'a')
     {
        if(!(Independent_condition_1 || Independent_condition_2))
        {
          // Do something
        }
      }
     else
      {
       if(!(Independent_condition_3 || Independent_condition_4)
        {
         // do something
        }
       }
     break;
      }
 case "b"
  {
  //similar if else ladder
  }   
}

接下来我会把它分解成不同的方法。通过将方法命名为适合您的领域的合理方法，您将使代码更具可读性。这也意味着当您进行更改时，您只需考虑您正在处理的小部分，而不是整个复杂的方法

switch(arg[0])
{ 
 case "a"
 {
  foreach(var c in obja)
  {
     newMethod(c);
     break;
      }
 case "b"
  {
  //similar if else ladder
  }   
}

void newMethod(str c) {
  if(c.entry == 'a')
     {
        if(!(Independent_condition_1 || Independent_condition_2))
        {
          // Do something
        }
      }
     else
      {
       if(!(Independent_condition_3 || Independent_condition_4)
        {
         // do something
        }
       }
}

---

然后，您可以继续将其分解为较小的、命名良好的方法，直到更容易理解为止。

首先，您的代码中有许多不必要的分支。我会合并并否定它们。这将使代码更具可读性

switch(arg[0])
{ 
 case "a"
 {
  foreach(var c in obja)
  {
     if(c.entry == 'a')
     {
        if(!(Independent_condition_1 || Independent_condition_2))
        {
          // Do something
        }
      }
     else
      {
       if(!(Independent_condition_3 || Independent_condition_4)
        {
         // do something
        }
       }
     break;
      }
 case "b"
  {
  //similar if else ladder
  }   
}

接下来我会把它分解成不同的方法。通过将方法命名为适合您的领域的合理方法，您将使代码更具可读性。这也意味着当您进行更改时，您只需考虑您正在处理的小部分，而不是整个复杂的方法

switch(arg[0])
{ 
 case "a"
 {
  foreach(var c in obja)
  {
     newMethod(c);
     break;
      }
 case "b"
  {
  //similar if else ladder
  }   
}

void newMethod(str c) {
  if(c.entry == 'a')
     {
        if(!(Independent_condition_1 || Independent_condition_2))
        {
          // Do something
        }
      }
     else
      {
       if(!(Independent_condition_3 || Independent_condition_4)
        {
         // do something
        }
       }
}

---

然后，您可以继续将其分解为较小的、命名良好的方法，直到更容易理解为止。

首先，您的代码中有许多不必要的分支。我会合并并否定它们。这将使代码更具可读性

switch(arg[0])
{ 
 case "a"
 {
  foreach(var c in obja)
  {
     if(c.entry == 'a')
     {
        if(!(Independent_condition_1 || Independent_condition_2))
        {
          // Do something
        }
      }
     else
      {
       if(!(Independent_condition_3 || Independent_condition_4)
        {
         // do something
        }
       }
     break;
      }
 case "b"
  {
  //similar if else ladder
  }   
}

接下来我会把它分解成不同的方法。通过将方法命名为适合您的领域的合理方法，您将使代码更具可读性。这也意味着当您进行更改时，您只需考虑您正在处理的小部分，而不是整个复杂的方法

switch(arg[0])
{ 
 case "a"
 {
  foreach(var c in obja)
  {
     newMethod(c);
     break;
      }
 case "b"
  {
  //similar if else ladder
  }   
}

void newMethod(str c) {
  if(c.entry == 'a')
     {
        if(!(Independent_condition_1 || Independent_condition_2))
        {
          // Do something
        }
      }
     else
      {
       if(!(Independent_condition_3 || Independent_condition_4)
        {
         // do something
        }
       }
}

---

然后，您可以继续将其分解为较小的、命名良好的方法，直到更容易理解为止。

您可以创建一个执行if/else操作的方法，并在交换机内部调用它，这样您就不会复制代码，也不会有大量的交换机块：

switch(arg[0])
{
     case "a":
        DoStuff('a');
        break;
     case "b":
        DoStuff('b');
        break;
     default:
        break;
}

private void DoStuff(char c)
{
   foreach(var c in obja)
   {
       if(c.entry == c)
       {
           if (Independent_condition_1)
           {
               // do logging
               continue;
           }
           if (Independent_condition_2)
           {
                // do logging
                continue;
           }
              // Do something if above two conditions are false
        }
        else
        {
            if (Independent_condition_3)
            {
                // do logging
                continue;
            }
            if (Independent_condition_4)
            {
                // do logging
                continue;
            }
            // do something if above 2 conditions are false.
        }
    }
}

---

您可以创建一个执行if/else的方法，并在交换机内部调用它，这样您就不会复制代码，也不会有大量的交换机块：

switch(arg[0])
{
     case "a":
        DoStuff('a');
        break;
     case "b":
        DoStuff('b');
        break;
     default:
        break;
}

private void DoStuff(char c)
{
   foreach(var c in obja)
   {
       if(c.entry == c)
       {
           if (Independent_condition_1)
           {
               // do logging
               continue;
           }
           if (Independent_condition_2)
           {
                // do logging
                continue;
           }
              // Do something if above two conditions are false
        }
        else
        {
            if (Independent_condition_3)
            {
                // do logging
                continue;
            }
            if (Independent_condition_4)
            {
                // do logging
                continue;
            }
            // do something if above 2 conditions are false.
        }
    }
}

---

您可以创建一个执行if/else的方法，并在交换机内部调用它，这样您就不会复制代码，也不会有大量的交换机块：

switch(arg[0])
{
     case "a":
        DoStuff('a');
        break;
     case "b":
        DoStuff('b');
        break;
     default:
        break;
}

private void DoStuff(char c)
{
   foreach(var c in obja)
   {
       if(c.entry == c)
       {
           if (Independent_condition_1)
           {
               // do logging
               continue;
           }
           if (Independent_condition_2)
           {
                // do logging
                continue;
           }
              // Do something if above two conditions are false
        }
        else
        {
            if (Independent_condition_3)
            {
                // do logging
                continue;
            }
            if (Independent_condition_4)
            {
                // do logging
                continue;
            }
            // do something if above 2 conditions are false.
        }
    }
}

---

您可以创建一个执行if/else的方法，并在交换机内部调用它，这样您就不会复制代码，也不会有大量的交换机块：

switch(arg[0])
{
     case "a":
        DoStuff('a');
        break;
     case "b":
        DoStuff('b');
        break;
     default:
        break;
}

private void DoStuff(char c)
{
   foreach(var c in obja)
   {
       if(c.entry == c)
       {
           if (Independent_condition_1)
           {
               // do logging
               continue;
           }
           if (Independent_condition_2)
           {
                // do logging
                continue;
           }
              // Do something if above two conditions are false
        }
        else
        {
            if (Independent_condition_3)
            {
                // do logging
                continue;
            }
            if (Independent_condition_4)
            {
                // do logging
                continue;
            }
            // do something if above 2 conditions are false.
        }
    }
}

问题是打赌