在> 0和> = 1之间的C＃中哪个更快更好？

Question

在> 0和> = 1之间的C＃中哪个更快更好？

Answer 1

未定义。你明确地要求C＃ - 但这是依赖于处理器体系结构的东西，即CLR运行时编译器。

Answer 2

两者都不;如果速度更快或更好，它们都应该编译成相同的东西。

更重要的是，大多数程序员可能会发现> 0更具可读性，并且可读性比这样的子微优化更重要。

Answer 3

两者之间的性能差异将会忽略不计（如果甚至有一个）。我正在努力证明它可能是什么（它将取决于平台，因为任何不同都可能归结为由JIT发出和执行的代码）。

请记住，虽然，性能明智这是一个极端的微观优化很可能是没有根据的。

更好的选择将会是更具可读性，并在您的代码中表达最好的意图。

Answer 4

要回答更快的问题，我不确定，但我认为它们是相同的。为了更好地回答，我认为这取决于上下文。

Answer 5

您不会注意到任何区别，除非可能在非常非常紧密的循环中对应用程序中的性能至关重要。然后你需要分析你的代码来决定哪个更好。

使用在您的应用程序中最有意义的那个。

Answer 6

更好的是最明确地表达您的意图。

如果您正在测试，看是否为整数的范围是[1,6]，那么你应该把它写成：

if (x >= 1 && x <= 6) { ... } 

写这会工作，但不会如此明显符合规范：

if (x > 0 && x < 7) { ... } 

我还假设你在这里谈论整数类型。如果你正在处理浮点或十进制数，那么它们是不相等的。

---

除非您对代码进行了剖析并发现这是瓶颈，否则您不应该担心微观优化问题。即使如此，在每种情况下检查由C＃编译器生成的代码以查看它们是否编译为相同的IL也会很有趣。这可以通过使用.NET Reflector来完成。

if (x >= 1) 
{ 
    Console.WriteLine("True!"); 
} 

结果：

L_000b: ldloc.0   // Load the value of x 
L_000c: ldc.i4.1   // Load the constant 1 
L_000d: blt.s L_0019  // Branch if less than 
L_000f: ldstr "True!" 
L_0014: call void [mscorlib]System.Console::WriteLine(string) 

鉴于：

if (x > 0) 
{ 
    Console.WriteLine("True!"); 
} 

导致以下IL：

L_000b: ldloc.0   // Load the value of x 
L_000c: ldc.i4.0   // Load the constant 0 
L_000d: ble.s L_0019  // Branch if less than or equal 
L_000f: ldstr "True!" 
L_0014: call void [mscorlib]System.Console::WriteLine(string) 

在两种情况下，编译器已经反转进行比较。 “大于或等于”测试编译为“小于”指令，“大于”测试编译为“小于或等于”。通常，编译器可以自由地进行这种修改，并运行不同版本的编译器可能会产生不同的（但相同的）字节码。

鉴于它们不会编译到同一个IL中，查看哪个最快的最好方法是实际在循环中运行代码，并查看每个版本执行需要多长时间。我试过这样做，但是在编写代码的两种方式之间我没有看到任何可测量的性能差异。

Answer 7

所以通常当我比较某些东西到> 0或> = 1时，我试图看看数组/集合是否包含任何元素。如果是这种情况，不要使用.Count > 0，请尝试使用System.Linq中的帮助器方法Enumerable.Any()，这应该快得多。

否则，我不知道:)

Answer 8

没有区别，因为CPU内部做两个数的减法和检查结果和溢出。任何一条指令都没有涉及额外的步骤。

说到代码，它取决于你要记录的内容。 > = 1表示1是可能的最小数字。 > 0表示不允许0。专业人士会注意到一个小的语义差异。他们会选择合适的运营商来记录他们的意图。

如果你认为> = n和> = N + 1，你错了一样的：> = int.MaxValue和>（int.MaxValue + 1）是不同的^^

Answer 9

我与同意通常不应考虑微观优化的其他反应。然而，看到两个版本中哪一个具有更小/明显更快的IL可能是有趣的。

所以：

using System; 

namespace IL_Test 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      int i = 3; 
      if (i > 0) 
      { 
       Console.Write("i is greater than zero"); 
      } 
     } 
    } 
} 

翻译成：

（调试）

.method private hidebysig static void Main(string[] args) cil managed 
{ 
    .entrypoint 
    .maxstack 2 
    .locals init (
     [0] int32 i, 
     [1] bool CS$4$0000) 
    L_0000: nop 
    L_0001: ldc.i4.3 
    L_0002: stloc.0 
    L_0003: ldloc.0 
    L_0004: ldc.i4.0 
    L_0005: cgt 
    L_0007: ldc.i4.0 
    L_0008: ceq 
    L_000a: stloc.1 
    L_000b: ldloc.1 
    L_000c: brtrue.s L_001b 
    L_000e: nop 
    L_000f: ldstr "i is greater than zero" 
    L_0014: call void [mscorlib]System.Console::Write(string) 
    L_0019: nop 
    L_001a: nop 
    L_001b: ret 
} 

（释放）

.method private hidebysig static void Main(string[] args) cil managed 
{ 
    .entrypoint 
    .maxstack 2 
    .locals init (
     [0] int32 i) 
    L_0000: ldc.i4.3 
    L_0001: stloc.0 
    L_0002: ldloc.0 
    L_0003: ldc.i4.0 
    L_0004: ble.s L_0010 
    L_0006: ldstr "i is greater than zero" 
    L_000b: call void [mscorlib]System.Console::Write(string) 
    L_0010: ret 
} 

而

using System; 

namespace IL_Test 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      int i = 3; 
      if (i >= 1) 
      { 
       Console.Write("i is greater than zero"); 
      } 
     } 
    } 
} 

成

（DEBUG）

.method private hidebysig static void Main(string[] args) cil managed 
{ 
    .entrypoint 
    .maxstack 2 
    .locals init (
     [0] int32 i, 
     [1] bool CS$4$0000) 
    L_0000: nop 
    L_0001: ldc.i4.3 
    L_0002: stloc.0 
    L_0003: ldloc.0 
    L_0004: ldc.i4.1 
    L_0005: clt 
    L_0007: stloc.1 
    L_0008: ldloc.1 
    L_0009: brtrue.s L_0018 
    L_000b: nop 
    L_000c: ldstr "i is greater than zero" 
    L_0011: call void [mscorlib]System.Console::Write(string) 
    L_0016: nop 
    L_0017: nop 
    L_0018: ret 
} 

（RELEASE）

.method private hidebysig static void Main(string[] args) cil managed 
{ 
    .entrypoint 
    .maxstack 2 
    .locals init (
     [0] int32 i) 
    L_0000: ldc.i4.3 
    L_0001: stloc.0 
    L_0002: ldloc.0 
    L_0003: ldc.i4.1 
    L_0004: blt.s L_0010 
    L_0006: ldstr "i is greater than zero" 
    L_000b: call void [mscorlib]System.Console::Write(string) 
    L_0010: ret 
} 

据我可以看到第i> = 1是略微快于I> 0 IN调试模式

在释放模式下l不同点在于抵消0004一个BLE vs一个BLT。我想这两个IL操作转化为CPU消耗本机操作系统..

Answer 10

当然，它取决于您的程序将运行在CPU架构。在x86上，与此处相关的jge和jg指令采用相同数量的周期IIRC。在测试大于0的特定情况下，如果使用无符号整数，则可能（我真的不知道）使用test指令代替cmp会更快，因为对于无符号整数，> 0等于！= 0其他体系结构可能不同。关键是，这是如此低级的，即使在极少数情况下值得优化，也没有硬件无关的方法来优化它。编辑：忘了提及：任何编译器或值得它的盐的虚拟机应该能够找出测试> = 1相当于测试> 0，并且如果它甚至在汇编语言上有所作为，那么执行如此微不足道的优化水平。

Answer 11

如果两者之间会有差异，那么我会说这是一个微型优化，它不应该影响应用程序的整体性能。此外，当人们真正弄清楚他是否必须使用> 0或者> = 1时，那么我认为计算出哪一个更快的成本并不会超过（最小的）性能收益。

因此，我还要说你应该使用最能表达意图的选项。