Question

可能重复：
Why is it good practice to return at the end of a method

我想知道在一个方法中使用几个RETURN语句是否可以被认为是好的做法以及为什么。如果没有，我想知道如何以不同的方式重写代码。

public string GetNominativeById(int? candidateId)
        {
            if (candidateId.HasValue)
                return repepositoryCandidate.GetById(candidateId.Value).Nominative;
             else
                return string.Empty;
            }
        }

使用一个RETURN

 public string GetNominativeById(int? candidateId)
    {
        string result;
        if (candidateId.HasValue)
            result =  repepositoryCandidate.GetById(candidateId.Value).Nominative;
         else
            result =  string.Empty;

        return result;
        }
    }

Answer 1

您实际上并不需要else

string GetNominativeById(int? candidateId)
{
    if (!candidateId.HasValue)  
        return string.Empty;

    return repepositoryCandidate.GetById(candidateId.Value).Nominative;
}

考虑这个反箭头模式：

if (condition1)
{
    if (condition2)
    {
        if (condition3)
        {
            // code lines
        }
    }
}

立即返回的方式将使您的代码更具可读性：

if (!condition1) return;
if (!condition2) return;
if (!condition3) return;

// code lines

Answer 2

不，这被认为是 ~~bad practice~~ 在方法中有多个退出点的不太好的做法。如果只有一个退出点，则更容易遵循代码。

然而，当该方法与示例中一样小时，无论如何都不难遵循代码，因此具有多个退出点并不是真正的问题。如果它使代码更简单，您可以很好地使用多个return语句。

Answer 3

虽然为了可读性目的，你应该努力只有一个return语句，但是有几个涉及多个return语句的模式。一个例子是 Guard Clause 。

保护条款的例子：

  public Foo merge (Foo a, Foo b) {
    if (a == null) return b;
    if (b == null) return a;
    // complicated merge code goes here.
  }

一些样式指南会让我们用一个单一的回复来写这个

  public Foo merge (Foo a, Foo b) {
    Foo result;
    if (a != null) {
      if (b != null) {
        // complicated merge code goes here.
      } else {
        result = a;
      }
    } else {
      result = b;
    }
    return result;
  }

另一种情况是当你想要从每个案例返回时的switch语句：

switch(foo)
{
   case "A":
     return "Foo";
   case "B":
     return "Bar";
   default:
     throw new NotSupportedException();
}

我会将您的代码重写为：

        public string GetNominativeById(int? candidateId)
        {
            return candidateId.HasValue 
                ? repepositoryCandidate.GetById(candidateId.Value).Nominative;
                : string.Empty;
        }

在一天结束时，请记住您（和其他开发人员）将多次读取您的代码，因此请确保它的可读性和显而易见性。

Answer 4

在维基百科上查看以下Article。您要问的是，您是否应该遵循结构化编程中的SESE（单项，单项退出）原则。

Answer 5

拥有更多的return语句没有任何问题，有时它实际上可以帮助你缩小代码并保存一些不必要的变量赋值，就像Cuong Le所指出的那样。：d

Answer 6

所有这些都取决于

您与其他开发人员一起使用的编码标准
和实际代码可读性（因此个人对代码的看法）

通常，当if/else变得过多时，我会使用return。

所以不要使用：

if(...)
{
    if(...)
    {
        if(...)
        {
        }
    }
    else if(...)
    {
    }
     ..
    else
    {
    }
}

使用return：

if(!...)
   return;

if(!...)
   return;

Answer 7

养成在方法结尾处添加return的习惯，因此您必须关闭所有活动对象（，如果您有）

public string GetNominativeById(int? candidateId)
{
    string _returnValue = string.Empty;
    if (candidateId.HasValue)
        _returnValue repepositoryCandidate.GetById(candidateId.Value).Nominative;
     else
        _returnValue =  string.Empty;

    return _returnValue;
}

旁注：三元运算符实际上并不是这个答案（我认为），因为在某些情况下，您的IF语句中存在多个代码块。

Answer 8

Structured programming的一条规则规定每个方法应该有一个入口和出口点。在这种情况下，只有一个退出点（return语句）意味着任何清理，例如调用Close或Dispose，只需要发生一次。具有多个出口点的影响对于小方法来说很小，但随着方法复杂性的增加而增加，可能很容易错过案例，或者作为重构或修改的代码。

Answer 9

你实际上不能在一个方法中使用多个return语句，你在代码中做了什么，你使用了if else语句，所以无论如何只会执行一个。你的代码对我来说似乎很好。

Answer 10

是，如果有必要，那么为什么不使用几个return语句。表现没有问题。

重写此代码：

public string GetNominativeById(int? candidateId)
{
    if (candidateId.HasValue)
          return repepositoryCandidate.GetById(candidateId.Value).Nominative;

    return string.empty;
}

或使用“三元运算符”。

public string GetNominativeById(int? candidateId)
{
     return candidateId.HasValue ? repepositoryCandidate.GetById(candidateId.Value).Nominative : string.Empty;  
}

Answer 11

为什么不呢？但你不需要别人。

public string GetNominativeById(int? candidateId)
        {
            if (candidateId.HasValue)
                return repepositoryCandidate.GetById(candidateId.Value).Nominative;
            return string.Empty;
        }

好的做法是在方法中多使用一个RETURN语句吗？

11 个答案: