为什么不能在string上使用流利的语言？
例如：
var x = "asdf1234";
var y = new string(x.TakeWhile(char.IsLetter).ToArray());
是不是有更好的方法将IEnumerable<char>转换为string？
这是我做的一个测试：
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 < times; i++)
{
string output = new string(input.TakeWhile(char.IsLetter).ToArray());
}
sw.Stop();
var first = sw.ElapsedTicks;
sw.Restart();
for (int i = 0; i < 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 < 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();
}
}
结果：
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%).
结论：我怀疑什么是更好的选择，我想我会继续使用TakeWhile，这是第一次运行时最慢的。
无论如何，我的问题是，是否有任何方法可以通过重新排列TakeWhile函数的结果来优化性能。
假设您主要关注性能，那么这样的事情应该比您的任何示例快得多：
string x = "asdf1234";
string y = x.LeadingLettersOnly();
// ...
public static class StringExtensions
{
public static string LeadingLettersOnly(this string source)
{
if (source == null)
throw new ArgumentNullException("source");
if (source.Length == 0)
return source;
char[] buffer = new char[source.Length];
int bufferIndex = 0;
for (int sourceIndex = 0; sourceIndex < source.Length; sourceIndex++)
{
char c = source[sourceIndex];
if (!char.IsLetter(c))
break;
buffer[bufferIndex++] = c;
}
return new string(buffer, 0, bufferIndex);
}
}
如何将IEnumerable<char>转换为string：
string.Concat(x.TakeWhile(char.IsLetter));
编辑发布.Net Core 2.1
重复测试.Net Core 2.1的发布，我得到这样的结果
“Concat”的1000000次迭代耗时842ms。
“新字符串”的1000000次迭代耗时1009ms。
“sb”的1000000次迭代耗时902ms。
简而言之，如果您使用.Net Core 2.1或更高版本，Concat就是王道。
有关详细信息，请参阅MS blog post。
我已经把它作为another question的主题，但越来越多，这正成为这个问题的直接答案。
我做了一些性能测试3种简单的方法，将IEnumerable<char>转换为string，这些方法是
新字符串
return new string(charSequence.ToArray());
CONCAT
return string.Concat(charSequence)
StringBuilder的
var sb = new StringBuilder();
foreach (var c in charSequence)
{
sb.Append(c);
}
return sb.ToString();
在我的测试中，这在linked question中详细说明，对于1000000的"Some reasonably small test data"迭代，我得到这样的结果，
“Concat”的1000000次迭代耗时1597ms。
“新字符串”的1000000次迭代耗时869ms。
“StringBuilder”的1000000次迭代耗时748ms。
这告诉我，没有充分的理由使用string.Concat完成这项任务。如果你想要简单，请使用新的字符串方法，如果想要性能，请使用StringBuilder。
我会告诫我的断言，在实践中所有这些方法都运行良好，这可能都是过度优化。
为什么不能在字符串上使用流利的语言？
有可能的。你在问题本身中做到了：
var y = new string(x.TakeWhile(char.IsLetter).ToArray());
有没有更好的方法将
IEnumerable<char>转换为字符串？
（我的假设是:)
框架没有这样的构造函数，因为字符串是不可变的，并且您必须遍历枚举两次才能为字符串预分配内存。这并不总是一个选项，特别是如果您的输入是一个流。
解决此问题的唯一方法是首先推送到支持数组或StringBuilder，并在输入增长时重新分配。对于像字符串一样低级的东西，这可能应该被视为过于隐藏的一种机制。它还会通过鼓励人们使用不能尽可能快的机制将perf问题推入字符串类。
通过要求用户使用ToArray扩展方法，可以轻松解决这些问题。
正如其他人所指出的，如果您编写支持代码，您可以实现您想要的（perf和表达代码），并将该支持代码包装在扩展方法中以获得干净的界面。
你经常可以做得更好。但这会给你带来什么？除非这确实是你的应用程序的瓶颈，并且你已经测量过它，我会坚持使用Linq TakeWhile()版本：它是最易读和可维护的解决方案，这对大多数应用程序来说都是重要的。
如果你真的在寻找原始性能，你可以手动进行转换 - 在我的测试中，以下是比TakeWhile()快4倍（取决于输入字符串长度） - 但我个人不会使用它，除非它很关键：
int j = 0;
for (; j < input.Length; j++)
{
if (!char.IsLetter(input[j]))
break;
}
string output = input.Substring(0, j);
return new string(foo.Select(x => x).ToArray());