Question

我有一些像这样编写的代码：

private double function1()
{
    double result2 = function2();
    if (result2  < 0) { return result2; }

    double result3 = function3();
    if (result3  < 0) { return result3; }

    return 0;
}

我需要重新编写它，使它只有一个return语句。是否有捷径可寻？从使用两次相同的if构造开始，这对我来说是低效的。如何清除这种低效率？

Answer 1

单线解决方案，不需要更改功能2/3。不是特别可读但很有趣：

private double function1()
{
    return new Func<double>[] { function2, function3 }
        .Select(c => c()).FirstOrDefault(c => c < 0);
}

就个人而言，我会选择你的原始版本。

Answer 2

保持简单，保持可读性。

// direct conversion of your code
private double function1()
{
    double result = 0;

    double result2 = function2();
    if (result2  < 0) 
    {
      result =  result2; 
    }
    else
    {
       double result3 = function3();
       if (result3  < 0) 
       {
         result = result3; 
       }
    }

    return result;
}

较短的版本，可能更容易看到眼睛：

private double function1()
{
    double result = function2();

    if (result >= 0)   // if (!(result < 0))  to be safe for NaN
    {
       result = function3();
       if (result >= 0) 
       {
         result = 0; 
       }
    }    
    return result;
}

和

从使用两次相同的if构造开始，这对我来说效率低下。

这没有什么低效率的。如果模式重复（更多），您可以开始考虑额外的方法或某些东西以提高可读性。

Answer 3

怎么样：

delegate void double DoubleReturningFunction();

private double function1()
{
    DoubleReturningFunction[] functions = { function2, function3 };

    foreach( DoubleReturningFunction function in functions )
    {
       double result = function();
       if( result < 0 ) return result;
    }

    return 0;
}

Answer 4

我需要重新编写它只有一个退货声明

确定真的需要吗？您的问题中显示的代码对我来说是完全有效和可读的。拥有多个return语句肯定不是问题;事实上，它可能比所有其他选择更清洁（参见答案）。

Answer 5

我实际上更喜欢带有多个退货的原始版本。但是，怎么样：

double ret = function2(); 
if (ret >= 0) 
    ret = function3();
if (ret > 0) 
    ret = 0;
return ret;

Answer 6

你可以这样做......

private double function1()
{
    var returnValue = 0;

    double result2 = function2();
    if (result2  < 0) { returnValue = result2; }

    double result3 = function3();
    if (result3  < 0) { returnValue = result3; }

    return returnValue;
}

但是，这可能会产生副作用，因为现在始终会调用function2和function3。所以，你必须有一个其他的，并增加像

这样的嵌套

private double function1()
{
    var returnValue = 0;

    double result2 = function2();
    if (result2  < 0) { 
        returnValue = result2; 
    } else {    
        double result3 = function3();
        if (result3  < 0) { returnValue = result3; }
    }

    return returnValue;
}

然后，它开始闻起来更多。如果函数2和3返回null而不是零，那么你可以这样做...在decimal?和decimal

之间进行转换时可能需要进行一些转换

private double function1()
{
    return function2() ?? function3() ?? 0;
}

Answer 7

这是我在约束中可以提出的最易读的版本。

    private double Function1()
    {
        double result = 1;

        if (result >= 0)
            result = Function2();

        if (result >= 0)
            result = Function3();

        if (result >= 0)
            result = 0;

        return result;
    }

这使得发生的事情变得非常明显。我非常确定优化器会删除第一个if表达式。

这种方法的优点是可以很容易地添加或重新确定函数的优先级。

重写多个return语句的简便方法

7 个答案: