title: Why is this Linq expression so much slower than the other?
body: <p>Time of execution: foo(1) >>> foo(2) >> foo(3)</p>
  
  <p>roughly: 1427349 >>> 14757 >> 1362</p>
  
  <p>foo(3) is the most optimized algorithm among the three, so I'm not surprised it's the fastest.
  What's surprising to me is that foo(2) is so much faster than foo(1). My impression is that foo(2) sorts, while foo(1) is operating similarly to foo(3). May I know what is the cause the slowdown for foo(1)? Show me what's under the hood. Thanks!</p>
  
  <pre><code>void Main()
  {   
      Random r = new Random();
      for(int i = 0; i &lt; array.Length; i++)
      {
          array[i] = new A(r.Next(int.MaxValue));
      }   
  
      foo(1); 
      foo(2);
      foo(3); 
  }
  
  A[] array = new A[10000];
  static Stopwatch sw = new Stopwatch();
  
  public void foo(int s)
  {
      sw.Reset();
      sw.Start();
  
      switch(s)
      {
          case 1:
              array.First(x =&gt; (x.value == array.Max(y =&gt; y.value))).Dump();
              break;
          case 2:
              array.OrderBy(x =&gt; x.value)
              .Last()
              .Dump();    
              break;
          case 3:
              {           
                  int max = array[0].value;
                  int index = 0;
                  int i = 0;
                  for(; i &lt; array.Length; i++)
                  {
                      if(array[i].value &gt;= max)
                      {
                          max = array[i].value;
                          index = i;
                      }
                  }
                  array[index].Dump();
              }
              break;
      }
  
      sw.Stop();
      sw.Dump();
  }
  class A
  {
      public int value;
      public A(int value)
      {
          this.value = value;
      }
  }
  </code></pre>
  
  <p>Code testing was in linqpad, so you can ignore the <code>.Dump()</code> method.</p>