C# 在属性中使用开关检索值时，我应该为开关语句或返回语句使用变量吗？

我应该在返回switch语句之前保存它的结果吗？或者当我得到它时，我应该返回开关中的值吗？有没有一种方式比另一种方式更好

使用临时变量：

      public double xMax {
      get {
           double val = 0.00f;
           switch(x_option) {
                case 0:
                     val = priMax;
                     break;
                case 1:
                     val = rfMax;
                     break;
                case 2:
                     val = pwMax;
                     break;
           }

           return val;
      }
 }

带返回语句：

 public double xMax {
      get {
           double val = 0.00f;
           switch(x_option) {
                case 0:
                     return priMax;
                case 1:
                     return rfMax;
                case 2:
                     return pwMax;
           }
      }
 }

---

是否存在性能差异和/或清理？

这是品味的问题，但如果可能的话，我更喜欢使用。它更容易调试，让您在更清楚地使用代码契约时检查pre和post。

我个人更喜欢第二种形式。它立即表明，一旦你得到了返回语句，你就完成了。对于额外的变量版本，您必须查看代码的其余部分，以查看是否还会发生任何其他情况

围绕单个返回点的信条在C中是有意义的，在这里你要确保你已经完成了所有的手动清理等等。但是，在一个你必须考虑异常的可能性的世界中，垃圾收集器处理大部分清理，用<代码>尝试/最后< /COD>处理其余部分，我发现在很多情况下，坚持使用一个退出点会使代码更难阅读，尤其是在可以在方法开始时就确定结果的情况下（例如，“如果输入字符串为空，结果总是为0，所以只需在那里返回它即可）

编辑：我只是想说清楚，在你的情况下，我不认为这有多大区别。但这是一种单点返回变得混乱的代码：

 public int DoSomething(string input1, string input2)
 {
     // First simple case
     if (input1 == null || input2 == null)
     {
         return -1;
     }

     // Second simple case
     int totalLength = input1.Length + input2.Length;
     if (totalLength < 10)
     {
         return totalLength;
     }

     // Imagine lots of lines here, using input1, input2 and totalLength
     // ...
     return someComplicatedResult;
 }

public int DoSomething（字符串input1，字符串input2）
{
//第一个简单案例
if（input1==null | | input2==null）
{
返回-1；
}
//第二个简单案例
int totalLength=输入1.长度+输入2.长度；
如果（总长度<10）
{
返回总长度；
}
//想象一下这里有很多行，使用input1、input2和totalLength
// ...
返回一些复杂的结果；
}

对于单点返回，这将成为：

 public int DoSomething(string input1, string input2)
 {
     int ret;

     // First simple case
     if (input1 == null || input2 == null)
     {

         ret = -1;
     }
     else
     {
         // Second simple case
         int totalLength = input1.Length + input2.Length;
         if (totalLength < 10)
         {
             ret = totalLength;
         }
         else
         {
             // Imagine lots of lines here, using input1, input2 and totalLength
             // ...
             ret = someComplicatedResult;
         }
     }
     return ret;
 }

public int DoSomething（字符串input1，字符串input2）
{
int ret；
//第一个简单案例
if（input1==null | | input2==null）
{
ret=-1；
}
其他的
{
//第二个简单案例
int totalLength=输入1.长度+输入2.长度；
如果（总长度<10）
{
ret=总长度；
}
其他的
{
//想象一下这里有很多行，使用input1、input2和totalLength
// ...
ret=一些复杂的结果；
}
}
返回ret；
}

我宁愿读第一份表格也不愿读第二份：

• 更多的嵌套通常会使代码更难理解，也很难记住要在哪里嵌套
• 在第一种形式中，您可以清楚地告诉—不必再阅读任何代码—如果您到达基本情况，您就完成了。在复杂的代码之后不会有任何副作用；我们只返回。在第二种代码中，您必须在心里跳过“else”“用积木来了解发生了什么。您正在查看更多代码以确定路径

---

我在华沙军事科技大学的第一个程序设计班，兹比格涅夫博士WESO·OWSKI说，函数只能有一个返回点。这是对ANSI-C编程的介绍，但他也告诉我们，我们永远不要忘记这一点，因为这是一条普遍的规则，无论我们必须用哪种语言开发。更重要的是，就像一个专制者，他说如果他尝试一次-甚至一次使用GOTO语句，在函数的中间返回，或者修改for循环中的迭代器。 无论是在中间还是不返回，这都是一个老龄化的困境。一些人声称它使代码更清晰，另一些人则认为它不优雅，应该避免使用。在我的经验中，我注意到，多个返回经常发生在java代码中，而C++、C++和C程序员也避免了。这不是规则，只是观察而已

另一个观察结果是java语言鼓励紧凑的语法。JavaIDE（例如eclipse）通常将默认格式化程序设置为将大括号放在同一行（只是一个简单的示例）。多个返回与该方法一致，允许进一步压缩代码

对面的VisualStudio将大括号作为唯一字符放在新行上。它鼓励使用清晰、粗体的语法，包括长文件、许多空白行或单字符行。我不知道哪一个更好，如果有的话

基本上，我在大学和家里的课堂上都写C。然后我更喜欢有空行的长文件

在我的公司，我写java代码，然后我更喜欢我习惯的更紧凑的风格。在公司中，我们使用checkstyle通过统一的样式来保持良好的代码质量。在公司存在多年的过程中，有一条支票式的规则，根本不允许多次退货

我在stackoverflow上看到过一篇帖子，其中有人说它对性能有影响。在回答中，他得到了一个简单的基准测试的结果。事实上，两者没有太大区别

---

在我的编码实践中，我宁愿避免多次返回。但是你的总体决定将取决于你个人的品味、经验、习惯、信念，也许还有质量要求。

好吧，最重要的是你不能把它们混在一起

第一种形式的动机之一是它有一个从getter退出的单点。如果代码比示例中的更复杂，这可能会很有用，但在这样一个简单的示例中，这并不重要

第二种形式的简单性是一个很好的参数，只要代码像示例中一样简单

---

您的第二个示例没有像现在这样编译，因为代码可能到达属性的末尾而不返回任何值

public double xMax {
  get {
    switch(x_option) {
      case 0:
        return priMax;
      case 1:
        return rfMax;
      case 2:
        return pwMax;
      default:
        return 0d;
    }
  }
}

public int DoSomething(string input1, string input2)
 {
     int ret;

     // First simple case
     if (input1 == null || input2 == null)
     {

         ret = -1;
     }
     else
     {
         // Second simple case
         int totalLength = input1.Length + input2.Length;
         if (totalLength < 10)
         {
             ret = totalLength;
         }
         else
         {
             // Imagine lots of lines here, using input1, input2 and totalLength
             // ...
             ret = someComplicatedResult;
         }
     }
     return ret;
 }

private int someComplicatedTask(string input1, string input2){
    // Second simple case
    int ret = 0;
    int totalLength = input1.Length + input2.Length;
    if (totalLength < 10)
    {
        ret = totalLength;
    }
    else
    {
       // Imagine lots of lines here, using input1, input2 and totalLength
       // ...
       ret = someComplicatedResult;
    }
    return ret;
}

public int DoSomething(string input1, string input2)
 {
     return input1 == null || input2 == null ? -1 : someComplecatedTask(...);
 }

...
if(input1 != null && input2 != null){
    output = DoSomething(input1, input2);
}
...

public int DoSomething(string input1, string input2)
{
    int len = input1.Length + input2.Length;
    return len < 10 ? len : someComplecatedTask(input1, input2);
}

private int someComplicatedTask(string input1, string input2){
    // Imagine lots of lines here, using input1, input2
    // ...
    return someComplicatedResult;
}

public double xMax {
      get {
           double val = 0.00f;
           switch(x_option) {
                case 0:
                     val = priMax;
                     break;
                case 1:
                     val = rfMax;
                     break;
                case 2:
                     val = pwMax;
                     break;
           }

           return val;
      }
 }

public double xMax {
      set {
           double val = 0.00f;
           switch(value) {
                case 0:
                     val = priMax;
                     break;
                case 1:
                     val = rfMax;
                     break;
                case 2:
                     val = pwMax;
                     break;
           }
           xmax = value * val; // say // This makes break better in switch.
      }
      get { return xmax; }
 }