1

这个问题更多的是性能问题而不是优雅，我为自己说话，但是......

有两个选项来实现，这对于 cpu 计算来说更快，或者如果最后它是相同的（我倾向于认为它是，因为条件是 (x<10) 相同）

    public int DidLogcount = 0; // DidLogCount is raised by +1 every time we deside, then condition is met 
    public bool MoreLogsAllowed()
    {
        if (DidLogcount < 10) return true;
        else return false;
    }

对比

    public bool MoreLogsAllowed()
    {
       return DidLogcount < 10;
    }

我们大部分时间都应该检查它是否不为空，但如果我们必须这样做，它会影响这两种情况，所以如果我没有错过任何其他问题，我猜我只是缩小了范围（？）。

我会应用正确的答案。谢谢。

重新编辑：我只是想标记正确的答案，但在页面上进行了刷新，又加载了 3 个......

将等待更多选票...现在，我真的要感谢大家！为了分享您的知识，我确实想到了编译器的优化问题，所以......虽然这些打印输出显示了一些东西，虽然它本身的差异很小，但是当添加到一堆条件时，它就更少了little ，除非我们谈论的是一个真正复杂的应用程序，否则我不会说 big 。我应该说，性能问题从来都不是小问题，还有逻辑和可读性，这要感谢@Steve 和@Nick 为我们实际测试它。

4

6 回答 6

5

我不确定是否会有任何性能差异，如果有的话，它可以忽略不计。但第二种情况更优雅。

于 2012-08-30T12:37:56.887 回答
4

用 LinqPAD 测试。

int DidLogcount = 5;
void Main()
{
    MoreLogsAllowed();
    MoreLogsAllowed2();
}

public bool MoreLogsAllowed() 
{ 
    if (DidLogcount < 10) return true; 
    else return false; 
} 

public bool MoreLogsAllowed2() 
{ 
    return (DidLogcount < 10); 
}

并生成此 IL 代码

IL_0000:  ldarg.0     
IL_0001:  call        UserQuery.MoreLogsAllowed
IL_0006:  pop         
IL_0007:  ldarg.0     
IL_0008:  call        UserQuery.MoreLogsAllowed2

MoreLogsAllowed:
IL_0000:  ldarg.0     
IL_0001:  ldfld       UserQuery.DidLogcount
IL_0006:  ldc.i4.s    0A 
IL_0008:  bge.s       IL_000C
IL_000A:  ldc.i4.1    
IL_000B:  ret         
IL_000C:  ldc.i4.0    
IL_000D:  ret         

MoreLogsAllowed2:
IL_0000:  ldarg.0     
IL_0001:  ldfld       UserQuery.DidLogcount
IL_0006:  ldc.i4.s    0A 
IL_0008:  clt         
IL_000A:  ret

第二个版本不仅更优雅，而且似乎产生了更短的代码。
为了确保这不是 LinqPAD 引入的差异，我使用 Visual Studio 2010 创建了一个小型控制台应用程序，并在发布模式下使用默认设置进行编译。
然后我用ILDASM看IL colde。
我确认上面的代码与编译器生成的代码相同。
当然差异可以忽略不计，但两个版本不会产生相同的 IL 代码。

于 2012-08-30T12:42:57.490 回答
2

如果这两种选择之间的性能存在差异，我会感到非常惊讶。我也发现第二种选择更优雅，我什至会省略括号。

然而，对于更复杂的条件，特别是在涉及函数调用的情况下，将两个 return 语句放在不同的行上可以更方便地在使用调试器单步执行代码时找出正在发生的事情。

于 2012-08-30T12:43:18.867 回答
2

对我来说，第一个例子没有优雅。此外，我认为编译器会优化第一种情况，所以没有什么可谈的。对我来说，第二个例子更简洁、更短、更易读。

于 2012-08-30T12:40:07.527 回答
2

任何性能差异都可能可以忽略不计，并且高度依赖于 .NET JIT 编译 - 但查看 x86 示例，比较结果如下：

                if (DidLogcount < 10) return true;
... skipped DidLogCount call...
    00000020  mov         dword ptr [ebp-4],eax 
    00000023  cmp         dword ptr [ebp-4],0Ah 
    00000027  jge         00000037 
    00000029  mov         eax,1 
    0000002e  and         eax,0FFh 
    00000033  mov         esp,ebp 
    00000035  pop         ebp 
    00000036  ret 
                else return false;
    00000037  xor         eax,eax 
    00000039  mov         esp,ebp 
    0000003b  pop         ebp 
    0000003c  ret

对比

            return (DidLogcount < 10);
    ... skipped DidLogCount call...
0000001f  mov         dword ptr [ebp-4],eax 
00000022  cmp         dword ptr [ebp-4],0Ah 
00000026  setl        al 
00000029  movzx       eax,al 
0000002c  mov         esp,ebp 
0000002e  pop         ebp 
0000002f  ret

后者可能会更快一些 - 但同样取决于您的 CPU 如何处理这些指令。

最好的答案是编写一个测试应用程序来衡量它！

于 2012-08-30T12:53:31.697 回答
0

两个片段之间没有区别，因为最重要的是 MSIL，在编译之后，在这种情况下，编译后的代码是相同的。

Code 1 C# -> MSIL 1 -> Code natif 1

Code 2 C# -> MSIL 1 -> Code natif 1
于 2012-08-30T12:45:23.933 回答