title: Best way to convert IEnumerable<char> to string?
body: <p>Why isn't it possible to use fluent language on <code>string</code>?</p>
  
  <p>For example:</p>
  
  <pre><code>var x = "asdf1234";
  var y = new string(x.TakeWhile(char.IsLetter).ToArray());
  </code></pre>
  
  <p>Isn't there a better way to convert <code>IEnumerable&lt;char&gt;</code> to <code>string</code>?</p>
  
  <p>Here is a test I've made:</p>
  
  <pre><code>class Program
  {
    static string input = "asdf1234";
    static void Main()
    {
      Console.WriteLine("1000 times:");
      RunTest(1000, input);
      Console.WriteLine("10000 times:");
      RunTest(10000,input);
      Console.WriteLine("100000 times:");
      RunTest(100000, input);
      Console.WriteLine("100000 times:");
      RunTest(100000, "ffff57467");
  
  
      Console.ReadKey();
  
    }
  
    static void RunTest( int times, string input)
    {
  
      Stopwatch sw = new Stopwatch();
  
      sw.Start();
      for (int i = 0; i &lt; times; i++)
      {
        string output = new string(input.TakeWhile(char.IsLetter).ToArray());
      }
      sw.Stop();
      var first = sw.ElapsedTicks;
  
      sw.Restart();
      for (int i = 0; i &lt; times; i++)
      {
        string output = Regex.Match(input, @"^[A-Z]+", 
          RegexOptions.IgnoreCase).Value;
      }
      sw.Stop();
      var second = sw.ElapsedTicks;
  
      var regex = new Regex(@"^[A-Z]+", 
        RegexOptions.IgnoreCase);
      sw.Restart();
      for (int i = 0; i &lt; times; i++)
      {
        var output = regex.Match(input).Value;
      }
      sw.Stop();
      var third = sw.ElapsedTicks;
  
      double percent = (first + second + third) / 100;
      double p1 = ( first / percent)/  100;
      double p2 = (second / percent )/100;
      double p3 = (third / percent  )/100;
  
  
      Console.WriteLine("TakeWhile took {0} ({1:P2}).,", first, p1);
      Console.WriteLine("Regex took {0}, ({1:P2})." , second,p2);
      Console.WriteLine("Preinstantiated Regex took {0}, ({1:P2}).", third,p3);
      Console.WriteLine();
    }
  }
  </code></pre>
  
  <p>Result:</p>
  
  <pre><code>1000 times:
  TakeWhile took 11217 (62.32%).,
  Regex took 5044, (28.02%).
  Preinstantiated Regex took 1741, (9.67%).
  
  10000 times:
  TakeWhile took 9210 (14.78%).,
  Regex took 32461, (52.10%).
  Preinstantiated Regex took 20669, (33.18%).
  
  100000 times:
  TakeWhile took 74945 (13.10%).,
  Regex took 324520, (56.70%).
  Preinstantiated Regex took 172913, (30.21%).
  
  100000 times:
  TakeWhile took 74511 (13.77%).,
  Regex took 297760, (55.03%).
  Preinstantiated Regex took 168911, (31.22%).
  </code></pre>
  
  <p>Conclusion: I'm doubting what's better to prefer, I think I'm gonna go on the <code>TakeWhile</code> which is the slowest only on first run.</p>
  
  <p>Anyway, my question is if there is any way to optimize the performance by restringing the result of the <code>TakeWhile</code> function.</p>