本文内容
- 使用 foreach 执行循环访问
- 使用迭代器方法的枚举源
- 深入了解 foreach
编写的几乎每个程序都需要循环访问集合。 因此需要编写代码来检查集合中的每一项。
还需创建迭代器方法,这些方法可为该类的元素生成迭代器。 迭代器是遍历容器的对象,尤其是列表。 迭代器可用于:
- 对集合中的每个项执行操作。
- 枚举自定义集合。
- 扩展 LINQ 或其他库。
- 创建数据管道,以便数据通过迭代器方法在管道中有效流动。
C# 语言提供用于生成和使用序列的功能。 可以同步或异步生成和使用这些序列。 本文概述了这些功能。
1、使用 foreach 执行循环访问
枚举集合非常简单:使用 foreach
关键字枚举集合,从而为集合中的每个元素执行一次嵌入语句:
foreach (var item in collection)
{
Console.WriteLine(item?.ToString());
}
就这样。 若要循环访问集合中的所有内容,只需使用 foreach
语句。 但 foreach
语句并非完美无缺。 它依赖于 .NET Core 库中定义的 2 个泛型接口,才能生成循环访问集合所需的代码:IEnumerable<T>
和 IEnumerator<T>
。 下文对此机制进行了更详细说明。
这 2 种接口还具备相应的非泛型接口:IEnumerable
和 IEnumerator
。 泛型版本是新式代码的首要选项。
异步生成序列时,可以使用 await foreach
语句异步使用此序列:
await foreach (var item in asyncSequence)
{
Console.WriteLine(item?.ToString());
}
如果序列是 System.Collections.Generic.IEnumerable<T>,则使用 foreach。 如果序列是 System.Collections.Generic.IAsyncEnumerable<T>,则使用 await foreach。 在后一种情况下,序列是异步生成的。
2、使用迭代器方法的枚举源
借助 C# 语言的另一个强大功能,能够生成创建枚举源的方法。 这些方法称为“迭代器方法”。 迭代器方法用于定义请求时如何在序列中生成对象。 使用 yield return
上下文关键字定义迭代器方法。
可编写此方法以生成从 0 到 9 的整数序列:
public IEnumerable<int> GetSingleDigitNumbers()
{
yield return 0;
yield return 1;
yield return 2;
yield return 3;
yield return 4;
yield return 5;
yield return 6;
yield return 7;
yield return 8;
yield return 9;
}
上方的代码显示了不同的 yield return
语句,以强调可在迭代器方法中使用多个离散 yield return
语句这一事实。 可以使用其他语言构造来简化迭代器方法的代码,这也是一贯的做法。 以下方法定义可生成完全相同的数字序列:
public IEnumerable<int> GetSingleDigitNumbersLoop()
{
int index = 0;
while (index < 10)
yield return index++;
}
不必从中选择一个。 可根据需要提供尽可能多的 yield return
语句来满足方法需求:
public IEnumerable<int> GetSetsOfNumbers()
{
int index = 0;
while (index < 10)
yield return index++;
yield return 50;
index = 100;
while (index < 110)
yield return index++;
}
上述所有示例都有一个异步对应项。 在每种情况下,将 IEnumerable<T>
的返回类型替换为 IAsyncEnumerable<T>
。 例如,前面的示例将具有以下异步版本:
public async IAsyncEnumerable<int> GetSetsOfNumbersAsync()
{
int index = 0;
while (index < 10)
yield return index++;
await Task.Delay(500);
yield return 50;
await Task.Delay(500);
index = 100;
while (index < 110)
yield return index++;
}
这是同步和异步迭代器的语法。 我们来看一个真实示例。 假设你正在处理一个 IoT 项目,设备传感器生成了大量数据流。 为了获知数据,需要编写一个对每第 N 个数据元素进行采样的方法。 通过以下小迭代器方法可实现此目的:
public static IEnumerable<T> Sample<T>(this IEnumerable<T> sourceSequence, int interval)
{
int index = 0;
foreach (T item in sourceSequence)
{
if (index++ % interval == 0)
yield return item;
}
}
如果从 IoT 设备读取生成异步序列,则修改方法,如以下方法所示:
public static async IAsyncEnumerable<T> Sample<T>(this IAsyncEnumerable<T> sourceSequence, int interval)
{
int index = 0;
await foreach (T item in sourceSequence)
{
if (index++ % interval == 0)
yield return item;
}
}
迭代器方法有一个重要限制:在同一方法中不能同时使用 return
语句和 yield return
语句。 以下代码无法编译:
public IEnumerable<int> GetSingleDigitNumbers()
{
int index = 0;
while (index < 10)
yield return index++;
yield return 50;
// generates a compile time error:
var items = new int[] {100, 101, 102, 103, 104, 105, 106, 107, 108, 109 };
return items;
}
此限制通常不是问题。 可以选择在整个方法中使用 yield return
,或选择将原始方法分成多个方法,一些使用 return
,另一些使用 yield return
。
可略微修改一下最后一个方法,使其可在任何位置使用 yield return
:
public IEnumerable<int> GetFirstDecile()
{
int index = 0;
while (index < 10)
yield return index++;
yield return 50;
var items = new int[] {100, 101, 102, 103, 104, 105, 106, 107, 108, 109 };
foreach (var item in items)
yield return item;
}
有时,正确的做法是将迭代器方法拆分成 2 个不同的方法。 一个使用 return
,另一个使用 yield return
。 考虑这样一种情况:需要基于布尔参数返回一个空集合,或者返回前 5 个奇数。 可编写类似以下 2 种方法的方法:
public IEnumerable<int> GetSingleDigitOddNumbers(bool getCollection)
{
if (getCollection == false)
return new int[0];
else
return IteratorMethod();
}
private IEnumerable<int> IteratorMethod()
{
int index = 0;
while (index < 10)
{
if (index % 2 == 1)
yield return index;
index++;
}
}
看看上面的方法。 第 1 个方法使用标准 return
语句返回空集合,或返回第 2 个方法创建的迭代器。 第 2 个方法使用 yield return
语句创建请求的序列。
3、深入了解 foreach
foreach
语句可扩展为使用 IEnumerable<T>
和 IEnumerator<T>
接口的标准用语,以便循环访问集合中的所有元素。 还可最大限度减少开发人员因未正确管理资源所造成的错误。
编译器将第 1 个示例中显示的 foreach
循环转换为类似于此构造的内容:
IEnumerator<int> enumerator = collection.GetEnumerator();
while (enumerator.MoveNext())
{
var item = enumerator.Current;
Console.WriteLine(item.ToString());
}
编译器生成的确切代码更复杂一些,用于处理 GetEnumerator()
返回的对象实现 IDisposable
接口的情况。 完整扩展生成的代码更类似如下:
{
var enumerator = collection.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
var item = enumerator.Current;
Console.WriteLine(item.ToString());
}
}
finally
{
// dispose of enumerator.
}
}
编译器将第一个异步示例转换为类似于此构造的内容:
{
var enumerator = collection.GetAsyncEnumerator();
try
{
while (await enumerator.MoveNextAsync())
{
var item = enumerator.Current;
Console.WriteLine(item.ToString());
}
}
finally
{
// dispose of async enumerator.
}
}
枚举器的释放方式取决于 enumerator
类型的特征。 在常规同步情况下,finally
子句扩展为:
finally
{
(enumerator as IDisposable)?.Dispose();
}
常规异步情况扩展为:
finally
{
if (enumerator is IAsyncDisposable asyncDisposable)
await asyncDisposable.DisposeAsync();
}
但是,如果 enumerator
的类型为已密封类型,并且不存在从类型 enumerator
到 IDisposable
或 IAsyncDisposable
的隐式转换,则 finally
子句扩展为一个空白块:
finally
{
}
如果存在从类型 enumerator
到 IDisposable
的隐式转换,并且 enumerator
是不可为 null 的值类型,则 finally
子句扩展为:
finally
{
((IDisposable)enumerator).Dispose();
}
幸运地是,无需记住所有这些细节。 foreach
语句会为你处理所有这些细微差别。 编译器会为所有这些构造生成正确的代码。