continue 的代码大约快一倍。
我在 LINQPad 中运行了以下代码，结果一致表明带有 continue 的子句的速度是原来的两倍。
void Main()
{
var headers = Enumerable.Range(1,1000).ToDictionary(i => "K"+i,i=> i % 2 == 0 ? null : "V"+i);
var stopwatch = new Stopwatch();
var sb = new StringBuilder();
stopwatch.Start();
foreach (var header in headers.Where(header => !String.IsNullOrEmpty(header.Value)))
sb.Append(header);
stopwatch.Stop();
Console.WriteLine("Using LINQ : " + stopwatch.ElapsedTicks);
sb.Clear();
stopwatch.Reset();
stopwatch.Start();
foreach (var header in headers)
{
if (String.IsNullOrEmpty(header.Value)) continue;
sb.Append(header);
}
stopwatch.Stop();
Console.WriteLine("Using continue : " + stopwatch.ElapsedTicks);
}
这是我得到的一些结果
Using LINQ : 1077
Using continue : 348
Using LINQ : 939
Using continue : 459
Using LINQ : 768
Using continue : 382
Using LINQ : 1256
Using continue : 457
Using LINQ : 875
Using continue : 318
一般而言，LINQ 在使用已评估的IEnumerable<T> 时总是比foreach 对应物要慢。原因是 LINQ-to-Objects 只是这些低级语言功能的高级包装器。在这里使用 LINQ 的好处不是性能，而是提供了一致的接口。 LINQ 绝对确实提供了性能优势，但是当您使用尚未在活动内存中的资源时它们会发挥作用（并允许您利用优化实际执行的代码的能力）。当替代代码是最佳替代方案时，LINQ 只需要通过一个冗余过程来调用您无论如何都会编写的相同代码。为了说明这一点，我将粘贴下面的代码，当您在加载的枚举上使用 LINQ 的 Where 运算符时实际调用的代码：
public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
{
if (source == null)
{
throw Error.ArgumentNull("source");
}
if (predicate == null)
{
throw Error.ArgumentNull("predicate");
}
if (source is Iterator<TSource>)
{
return ((Iterator<TSource>) source).Where(predicate);
}
if (source is TSource[])
{
return new WhereArrayIterator<TSource>((TSource[]) source, predicate);
}
if (source is List<TSource>)
{
return new WhereListIterator<TSource>((List<TSource>) source, predicate);
}
return new WhereEnumerableIterator<TSource>(source, predicate);
}
这里是WhereSelectEnumerableIterator<TSource,TResult> 类。 predicate 字段是您传递给Where() 方法的委托。您将看到它在MoveNext 方法中实际执行的位置（以及所有冗余的空检查）。您还将看到可枚举仅循环一次。堆叠where 子句将导致创建多个迭代器类（包装它们的前辈），但不会导致多个枚举操作（由于延迟执行）。请记住，当您编写这样的 Lambda 时，您实际上也在创建一个新的 Delegate 实例（也会以较小的方式影响您的性能）。
private class WhereSelectEnumerableIterator<TSource, TResult> : Enumerable.Iterator<TResult>
{
private IEnumerator<TSource> enumerator;
private Func<TSource, bool> predicate;
private Func<TSource, TResult> selector;
private IEnumerable<TSource> source;
public WhereSelectEnumerableIterator(IEnumerable<TSource> source, Func<TSource, bool> predicate, Func<TSource, TResult> selector)
{
this.source = source;
this.predicate = predicate;
this.selector = selector;
}
public override Enumerable.Iterator<TResult> Clone()
{
return new Enumerable.WhereSelectEnumerableIterator<TSource, TResult>(this.source, this.predicate, this.selector);
}
public override void Dispose()
{
if (this.enumerator != null)
{
this.enumerator.Dispose();
}
this.enumerator = null;
base.Dispose();
}
public override bool MoveNext()
{
switch (base.state)
{
case 1:
this.enumerator = this.source.GetEnumerator();
base.state = 2;
break;
case 2:
break;
default:
goto Label_007C;
}
while (this.enumerator.MoveNext())
{
TSource current = this.enumerator.Current;
if ((this.predicate == null) || this.predicate(current))
{
base.current = this.selector(current);
return true;
}
}
this.Dispose();
Label_007C:
return false;
}
public override IEnumerable<TResult2> Select<TResult2>(Func<TResult, TResult2> selector)
{
return new Enumerable.WhereSelectEnumerableIterator<TSource, TResult2>(this.source, this.predicate, Enumerable.CombineSelectors<TSource, TResult, TResult2>(this.selector, selector));
}
public override IEnumerable<TResult> Where(Func<TResult, bool> predicate)
{
return (IEnumerable<TResult>) new Enumerable.WhereEnumerableIterator<TResult>(this, predicate);
}
}
我个人认为性能差异是完全合理的，因为 LINQ 代码更容易维护和重用。我还做一些事情来抵消性能问题（比如将我所有的匿名 lambda 委托和表达式声明为公共类中的静态只读字段）。但就您的实际问题而言，您的 continue 子句肯定比 LINQ 替代方案快。