答案太多了，但我发现了一些有趣的东西，非常简单的改变就能产生影响。在进行以下更改后，执行if-else和三元运算符将花费相同的时间。

而不是写在线下

value +=  i > 0 ? 2 : 3;

我用了这个，

int a =  i > 0 ? 2 : 3;
value += a;

下面其中一个回答也提到了写三元运算符有什么不好的方法。

我希望这能帮助你写三元运算符，而不是思考哪个更好。

嵌套三元运算符: 我发现嵌套的三元运算符和多个if else块也将花费相同的时间来执行。

这个区别与if/else和三元没有太大关系。

看看这些分解(我不会在这里重复，请参阅@280Z28的答案)，结果是你在比较苹果和橘子。在一种情况下，创建两个具有常量值的不同+=操作，选择哪个操作取决于条件;在另一种情况下，创建+=，其中要添加的值取决于条件。

如果你想真正比较If /else和三元，这将是一个更公平的比较(现在两者都一样“慢”，或者我们甚至可以说三元更快一点):

int diff;
if (i > 0) 
    diff = 2;
else 
    diff = 3;
value += diff;

vs.

value += i > 0 ? 2 : 3;

现在，对if/else的分解如下所示。注意，这比三元情况更糟糕，因为它也停止使用循环变量(i)的寄存器。

                if (i > 0)
0000009d  cmp         dword ptr [ebp-20h],0 
000000a1  jle         000000AD 
                {
                    diff = 2;
000000a3  mov         dword ptr [ebp-24h],2 
000000aa  nop 
000000ab  jmp         000000B4 
                }
                else
                {
                    diff = 3;
000000ad  mov         dword ptr [ebp-24h],3 
                }
                value += diff;
000000b4  mov         eax,dword ptr [ebp-18h] 
000000b7  mov         edx,dword ptr [ebp-14h] 
000000ba  mov         ecx,dword ptr [ebp-24h] 
000000bd  mov         ebx,ecx 
000000bf  sar         ebx,1Fh 
000000c2  add         eax,ecx 
000000c4  adc         edx,ebx 
000000c6  mov         dword ptr [ebp-18h],eax 
000000c9  mov         dword ptr [ebp-14h],edx 
000000cc  inc         dword ptr [ebp-28h] 

编辑:所有更改…见下文。

我不能在x64 CLR上重现你的结果，但我可以在x86上。在x64上，我可以看到条件操作符和if/else之间有一个很小的差异(小于10%)，但它比您看到的要小得多。

我做了以下可能的更改:

在控制台应用程序中运行 使用/o+ /debug-构建，并在调试器外部运行 运行这两段代码一次以JIT它们，然后多次以获得更高的准确性 使用秒表

使用/platform:x64的结果(没有“忽略”行):

if/else with 1 iterations: 17ms
conditional with 1 iterations: 19ms
if/else with 1000 iterations: 17875ms
conditional with 1000 iterations: 19089ms

使用/platform:x86的结果(没有“ignore”行):

if/else with 1 iterations: 18ms
conditional with 1 iterations: 49ms
if/else with 1000 iterations: 17901ms
conditional with 1000 iterations: 47710ms

我的系统详细信息:

x64 i7-2720QM CPU @2.20GHz 64位Windows 8 net 4.5

因此，与以前不同的是，我认为您看到了真正的不同——这都与x86 JIT有关。我不想确切地说是什么导致了这种差异-如果我能麻烦进入cordbg，我可能会在后面更新更多的细节。

有趣的是，如果不先对数组排序，我最终的测试时间大约是原来的4.5倍，至少在x64上。我猜想这与分支预测有关。

代码:

using System;
using System.Diagnostics;

class Test
{
    static void Main()
    {
        Random r = new Random(0);
        int[] array = new int[20000000];
        for(int i = 0; i < array.Length; i++)
        {
            array[i] = r.Next(int.MinValue, int.MaxValue);
        }
        Array.Sort(array);
        // JIT everything...
        RunIfElse(array, 1);
        RunConditional(array, 1);
        // Now really time it
        RunIfElse(array, 1000);
        RunConditional(array, 1000);
    }

    static void RunIfElse(int[] array, int iterations)
    {        
        long value = 0;
        Stopwatch sw = Stopwatch.StartNew();

        for (int x = 0; x < iterations; x++)
        {
            foreach (int i in array)
            {
                if (i > 0)
                {
                    value += 2;
                }
                else
                {
                    value += 3;
                }
            }
        }
        sw.Stop();
        Console.WriteLine("if/else with {0} iterations: {1}ms",
                          iterations,
                          sw.ElapsedMilliseconds);
        // Just to avoid optimizing everything away
        Console.WriteLine("Value (ignore): {0}", value);
    }

    static void RunConditional(int[] array, int iterations)
    {        
        long value = 0;
        Stopwatch sw = Stopwatch.StartNew();

        for (int x = 0; x < iterations; x++)
        {
            foreach (int i in array)
            {
                value += i > 0 ? 2 : 3;
            }
        }
        sw.Stop();
        Console.WriteLine("conditional with {0} iterations: {1}ms",
                          iterations,
                          sw.ElapsedMilliseconds);
        // Just to avoid optimizing everything away
        Console.WriteLine("Value (ignore): {0}", value);
    }
}

在下面的代码中，if/else似乎大约比三元运算符快1.4倍。然而，我发现引入一个临时变量会使三元运算符的运行时间减少约1.4倍:

If/Else: 98毫秒 三元:141毫秒 三元与温度变量:100毫秒

using System;
using System.Diagnostics;

namespace ConsoleApplicationTestIfElseVsTernaryOperator
{
    class Program
    {
        static void Main(string[] args)
        {
            Random r = new Random(0);
            int[] array = new int[20000000];
            for (int i = 0; i < array.Length; i++)
            {
                array[i] = r.Next(int.MinValue, int.MaxValue);
            }
            Array.Sort(array);
            long value;
            Stopwatch stopwatch = new Stopwatch();

            value = 0;
            stopwatch.Restart();
            foreach (int i in array)
            {
                if (i > 0)
                {
                    value += 2;
                }
                else
                {
                    value += 3;
                }
                // 98 ms
            }
            stopwatch.Stop();
            Console.WriteLine("If/Else: " + stopwatch.ElapsedMilliseconds.ToString() + " ms");

            value = 0;
            stopwatch.Restart();
            foreach (int i in array)
            {
                value += (i > 0) ? 2 : 3; 
                // 141 ms
            }

            stopwatch.Stop();
            Console.WriteLine("Ternary: " + stopwatch.ElapsedMilliseconds.ToString() + " ms");

            value = 0;
            int tempVar = 0;
            stopwatch.Restart();
            foreach (int i in array)
            {
                tempVar = (i > 0) ? 2 : 3;
                value += tempVar; 
                // 100ms
            }
            stopwatch.Stop();
            Console.WriteLine("Ternary with temp var: " + stopwatch.ElapsedMilliseconds.ToString() + " ms");

            Console.ReadKey(true);
        }
    }
}

在没有调试ctrl+F5的情况下运行，调试器似乎使if和三元操作符都显着变慢，但似乎它使三元操作符变慢得更多。

当我运行以下代码时，这里是我的结果。我认为微小的毫秒差异是由编译器优化max=max并删除它造成的，但可能没有对三元操作符进行优化。如果有人能检查组装并确认这一点，那就太棒了。

--Run #1--
Type   | Milliseconds
Ternary 706
If     704
%: .9972
--Run #2--
Type   | Milliseconds
Ternary 707
If     704
%: .9958
--Run #3--
Type   | Milliseconds
Ternary 706
If     704
%: .9972

Code

  for (int t = 1; t != 10; t++)
        {
            var s = new System.Diagnostics.Stopwatch();
            var r = new Random(123456789);   //r
            int[] randomSet = new int[1000]; //a
            for (int i = 0; i < 1000; i++)   //n
                randomSet[i] = r.Next();     //dom
            long _ternary = 0; //store
            long _if = 0;      //time
            int max = 0; //result
            s.Start();
            for (int q = 0; q < 1000000; q++)
            {
                for (int i = 0; i < 1000; i++)
                    max = max > randomSet[i] ? max : randomSet[i];
            }
            s.Stop();
            _ternary = s.ElapsedMilliseconds;
            max = 0;
            s = new System.Diagnostics.Stopwatch();
            s.Start();
            for (int q = 0; q < 1000000; q++)
            {
                for (int i = 0; i < 1000; i++)
                    if (max > randomSet[i])
                        max = max; // I think the compiler may remove this but not for the ternary causing the speed difference.
                    else
                        max = randomSet[i];
            }

            s.Stop();
            _if = s.ElapsedMilliseconds;
            Console.WriteLine("--Run #" + t+"--");
            Console.WriteLine("Type   | Milliseconds\nTernary {0}\nIf     {1}\n%: {2}", _ternary, _if,((decimal)_if/(decimal)_ternary).ToString("#.####"));
        }

编辑:

增加了一个可以使用if-else语句但不能使用条件操作符的示例。

---

在回答之前，请先看一下[哪个更快?]在利伯特的博客上。我认为Ersönmez先生的答案是最正确的。

我试图提到一些我们应该记住的高级编程语言。

首先，我从未听说过条件运算符应该比c#中的if-else语句更快或性能相同。

原因很简单，如果没有if-else语句的操作:

if (i > 0)
{
    value += 2;
}
else
{
}

条件操作符的要求是:必须有一个值的任意边，并且在c#中，它还要求:的两端具有相同的类型。这只是使它不同于if-else语句。因此，你的问题变成了问指令的机器代码是如何产生的，从而导致性能的差异。

如果使用条件操作符，从语义上讲它是:

无论表达式的值是多少，都有一个值。

但是使用if-else语句:

如果表达式被赋值为true，执行一些操作;如果没有，做另一件事。

if-else语句不一定包含值。你的假设只有在优化时才有可能。

另一个例子可以说明它们之间的区别，如下所示:

var array1=new[] { 1, 2, 3 };
var array2=new[] { 5, 6, 7 };

if(i>0)
    array1[1]=4;
else
    array2[2]=4;

上面的代码编译，但是，用条件操作符替换if-else语句不会编译:

var array1=new[] { 1, 2, 3 };
var array2=new[] { 5, 6, 7 };
(i>0?array1[1]:array2[2])=4; // incorrect usage 

当你做同样的事情时，条件操作符和if-else语句在概念上是相同的，在C中使用条件操作符可能更快，因为C更接近平台的程序集。

---

对于您提供的原始代码，条件操作符在foreach循环中使用，这将使查看它们之间的区别变得混乱。所以我提议以下代码:

public static class TestClass {
    public static void TestConditionalOperator(int i) {
        long value=0;
        value+=i>0?2:3;
    }

    public static void TestIfElse(int i) {
        long value=0;

        if(i>0) {
            value+=2;
        }
        else {
            value+=3;
        }
    }

    public static void TestMethod() {
        TestConditionalOperator(0);
        TestIfElse(0);
    }
}

以下是优化和未优化的IL的两个版本。因为它们很长，我用一张图片来展示，右边是优化后的:

(点击查看全尺寸图片。)

在这两个版本的代码中，条件操作符的IL看起来都比if-else语句短，并且最终生成的机器代码仍然存在疑问。以下是两种方法的说明，前者为未优化图像，后者为优化图像:

非优化说明:(点击查看全尺寸图片) 优化说明:(点击查看全尺寸图片)

在后者中，黄色块是仅当i<=0时执行的代码，蓝色块是当i>0时执行的代码。在任何版本的指令中，if-else语句都较短。

请注意，对于不同的指令，[CPI]不一定相同。逻辑上，对于相同的指令，更多的指令需要更长的周期。但是如果将指令获取时间和管道/缓存也考虑在内，那么实际的总执行时间取决于处理器。处理器还可以预测分支。

现代处理器甚至有更多的核心，事情可能会更复杂。如果你是英特尔处理器的用户，你可能想看一下[英特尔®64和IA-32架构优化参考手册]。

我不知道是否有硬件实现的CLR，但如果有，使用条件操作符可能会更快，因为IL明显更少。

注:所有机器代码都是x86的。