试试IEnumerable的另外6个小例子

IEnumerable 接口是 C# 开发过程中非常重要的接口,对于其特性和用法的了解是十分必要的。本文将通过6个小例子,来熟悉一下其简单的用法。

阅读建议

  • 在阅读本篇时,建议先阅读前篇《试试IEnumerable的10个小例子》,更加助于读者理解。
  • 阅读并理解本篇需要花费5-10分钟左右的时间,而且其中包含一些实践建议。建议先收藏本文,闲时阅读并实践。

全是源码

以下便是这6个小例子,相应的说明均标记在注释中。

每个以 TXX 开头命名的均是一个示例。建议从上往下阅读。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
using System;
using System.Collections.Generic;
using System.Linq;
using FluentAssertions;
using Xunit;
using Xunit.Abstractions;

namespace Try_More_On_IEnumerable
{
public class EnumerableTests2
{
private readonly ITestOutputHelper _testOutputHelper;

public EnumerableTests2(
ITestOutputHelper testOutputHelper)
{
_testOutputHelper = testOutputHelper;
}

[Fact]
public void T11分组合并()
{
var array1 = new[] {0, 1, 2, 3, 4};
var array2 = new[] {5, 6, 7, 8, 9};

// 通过本地方法合并两个数组为一个数据
var result1 = ConcatArray(array1, array2).ToArray();

// 使用 Linq 中的 Concat 来合并两个 IEnumerable 对象
var result2 = array1.Concat(array2).ToArray();

// 使用 Linq 中的 SelectMany 将 “二维数据” 拉平合并为一个数组
var result3 = new[] {array1, array2}.SelectMany(x => x).ToArray();

/**
* 使用 Enumerable.Range 生成一个数组,这个数据的结果为
* 0,1,2,3,4,5,6,7,8,9
*/
var result = Enumerable.Range(0, 10).ToArray();

// 通过以上三种方式合并的结果时相同的
result1.Should().Equal(result);
result2.Should().Equal(result);
result3.Should().Equal(result);

IEnumerable<T> ConcatArray<T>(IEnumerable<T> source1, IEnumerable<T> source2)
{
foreach (var item in source1)
{
yield return item;
}

foreach (var item in source2)
{
yield return item;
}
}
}

[Fact]
public void T12拉平三重循环()
{
/**
* 通过本地函数获取 0-999 共 1000 个数字。
* 在 GetSomeData 通过三重循环构造这些数据
* 值得注意的是 GetSomeData 隐藏了三重循环的细节
*/
var result1 = GetSomeData(10, 10, 10)
.ToArray();

/**
* 与 GetSomeData 方法对比,将“遍历”和“处理”两个逻辑进行了分离。
* “遍历”指的是三重循环本身。
* “处理”指的是三重循环最内部的加法过程。
* 这里通过 Select 方法,将“处理”过程抽离了出来。
* 这其实和 “T03分离条件”中使用 Where 使用的是相同的思想。
*/
var result2 = GetSomeData2(10, 10, 10)
.Select(tuple => tuple.i * 100 + tuple.j * 10 + tuple.k)
.ToArray();

// 生成一个 0-999 的数组。
var result = Enumerable.Range(0, 1000).ToArray();

result1.Should().Equal(result);
result2.Should().Equal(result);

IEnumerable<int> GetSomeData(int maxI, int maxJ, int maxK)
{
for (var i = 0; i < maxI; i++)
{
for (var j = 0; j < maxJ; j++)
{
for (var k = 0; k < maxK; k++)
{
yield return i * 100 + j * 10 + k;
}
}
}
}

IEnumerable<(int i, int j, int k)> GetSomeData2(int maxI, int maxJ, int maxK)
{
for (var i = 0; i < maxI; i++)
{
for (var j = 0; j < maxJ; j++)
{
for (var k = 0; k < maxK; k++)
{
yield return (i, j, k);
}
}
}
}
}

private class TreeNode
{
public TreeNode()
{
Children = Enumerable.Empty<TreeNode>();
}

/// <summary>
/// 当前节点的值
/// </summary>
public int Value { get; set; }

/// <summary>
/// 当前节点的子节点列表
/// </summary>
public IEnumerable<TreeNode> Children { get; set; }
}

[Fact]
public void T13遍历树()
{
/**
* 树结构如下:
* └─0
* ├─1
* │ └─3
* └─2
*/
var tree = new TreeNode
{
Value = 0,
Children = new[]
{
new TreeNode
{
Value = 1,
Children = new[]
{
new TreeNode
{
Value = 3
},
}
},
new TreeNode
{
Value = 2
},
}
};

// 深度优先遍历的结果
var dftResult = new[] {0, 1, 3, 2};

// 通过迭代器实现深度优先遍历
var dft = DFTByEnumerable(tree).ToArray();
dft.Should().Equal(dftResult);

// 使用堆栈配合循环算法实现深度优先遍历
var dftList = DFTByStack(tree).ToArray();
dftList.Should().Equal(dftResult);

// 递归算法实现深度优先遍历
var dftByRecursion = DFTByRecursion(tree).ToArray();
dftByRecursion.Should().Equal(dftResult);

// 广度优先遍历的结果
var bdfResult = new[] {0, 1, 2, 3};

/**
* 通过迭代器实现广度优先遍历
* 此处未提供“通过队列配合循环算法”和“递归算法”实现广度优先遍历的两种算法进行对比。读者可以自行尝试。
*/
var bft = BFT(tree).ToArray();
bft.Should().Equal(bdfResult);

/**
* 迭代器深度优先遍历
* depth-first traversal
*/
IEnumerable<int> DFTByEnumerable(TreeNode root)
{
yield return root.Value;
foreach (var child in root.Children)
{
foreach (var item in DFTByEnumerable(child))
{
yield return item;
}
}
}

// 使用堆栈配合循环算法实现深度优先遍历
IEnumerable<int> DFTByStack(TreeNode root)
{
var result = new List<int>();
var stack = new Stack<TreeNode>();
stack.Push(root);
while (stack.TryPop(out var node))
{
result.Add(node.Value);
foreach (var nodeChild in node.Children.Reverse())
{
stack.Push(nodeChild);
}
}

return result;
}

// 递归算法实现深度优先遍历
IEnumerable<int> DFTByRecursion(TreeNode root)
{
var list = new List<int> {root.Value};
foreach (var rootChild in root.Children)
{
list.AddRange(DFTByRecursion(rootChild));
}

return list;
}

// 通过迭代器实现广度优先遍历
IEnumerable<int> BFT(TreeNode root)
{
yield return root.Value;

foreach (var bftChild in BFTChildren(root.Children))
{
yield return bftChild;
}

IEnumerable<int> BFTChildren(IEnumerable<TreeNode> children)
{
var tempList = new List<TreeNode>();
foreach (var treeNode in children)
{
tempList.Add(treeNode);
yield return treeNode.Value;
}

foreach (var bftChild in tempList.SelectMany(treeNode => BFTChildren(treeNode.Children)))
{
yield return bftChild;
}
}
}
}

[Fact]
public void T14搜索树()
{
/**
* 此处所指的搜索树是指在遍历树的基础上增加终结遍历的条件。
* 因为一般构建搜索树是为了找到第一个满足条件的数据,因此与单纯的遍历存在不同。
* 树结构如下:
* └─0
* ├─1
* │ └─3
* └─5
* └─2
*/

var tree = new TreeNode
{
Value = 0,
Children = new[]
{
new TreeNode
{
Value = 1,
Children = new[]
{
new TreeNode
{
Value = 3
},
}
},
new TreeNode
{
Value = 5,
Children = new[]
{
new TreeNode
{
Value = 2
},
}
},
}
};

/**
* 有了深度优先遍历算法的情况下,再增加一个条件判断,便可以实现深度优先的搜索
* 搜索树中第一个大于等于 3 并且是奇数的数字
*/
var result = DFS(tree, x => x >= 3 && x % 2 == 1);

/**
* 搜索到的结果是3。
* 特别提出,如果使用广度优先搜索,结果应该是5。
* 读者可以通过 T13遍历树 中的广度优先遍历算法配合 FirstOrDefault 中相同的条件实现。
* 建议读者尝试以上代码尝试一下。
*/
result.Should().Be(3);

int DFS(TreeNode root, Func<int, bool> predicate)
{
var re = DFTByEnumerable(root)
.FirstOrDefault(predicate);
return re;
}

// 迭代器深度优先遍历
IEnumerable<int> DFTByEnumerable(TreeNode root)
{
yield return root.Value;
foreach (var child in root.Children)
{
foreach (var item in DFTByEnumerable(child))
{
yield return item;
}
}
}
}

[Fact]
public void T15分页()
{
var arraySource = new[] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

// 使用迭代器进行分页,每 3 个一页
var enumerablePagedResult = PageByEnumerable(arraySource, 3).ToArray();

// 结果一共 4 页
enumerablePagedResult.Should().HaveCount(4);
// 最后一页只有一个数字,为 9
enumerablePagedResult.Last().Should().Equal(9);


// 通过常规的 Skip 和 Take 来分页是最为常见的办法。结果应该与上面的分页结果一样
var result3 = NormalPage(arraySource, 3).ToArray();

result3.Should().HaveCount(4);
result3.Last().Should().Equal(9);

IEnumerable<IEnumerable<int>> PageByEnumerable(IEnumerable<int> source, int pageSize)
{
var onePage = new LinkedList<int>();
foreach (var i in source)
{
onePage.AddLast(i);
if (onePage.Count != pageSize)
{
continue;
}

yield return onePage;
onePage = new LinkedList<int>();
}

// 最后一页如果数据不足一页,也应该返回该页
if (onePage.Count > 0)
{
yield return onePage;
}
}

IEnumerable<IEnumerable<int>> NormalPage(IReadOnlyCollection<int> source, int pageSize)
{
var pageCount = Math.Ceiling(1.0 * source.Count / pageSize);
for (var i = 0; i < pageCount; i++)
{
var offset = i * pageSize;
var onePage = source
.Skip(offset)
.Take(pageSize);
yield return onePage;
}
}

/**
* 从写法逻辑上来看,显然 NormalPage 的写法更容易让大众接受
* PageByEnumerable 写法在仅仅只有在一些特殊的情况下才能体现性能上的优势,可读性上却不如 NormalPage
*/
}

[Fact]
public void T16分页与多级缓存()
{
/**
* 获取 5 页数据,每页 2 个。
* 依次从 内存、Redis、ElasticSearch和数据库中获取数据。
* 先从内存中获取数据,如果内存中数据不足页,则从 Redis 中获取。
* 若 Redis 获取后还是不足页,进而从 ElasticSearch 中获取。依次类推,直到足页或者再无数据
*/
const int pageSize = 2;
const int pageCount = 5;
var emptyData = Enumerable.Empty<int>().ToArray();

/**
* 初始化各数据源的数据,除了内存有数据外,其他数据源均没有数据
*/
var memoryData = new[] {0, 1, 2};
var redisData = emptyData;
var elasticSearchData = emptyData;
var databaseData = emptyData;

var result = GetSourceData()
// ToPagination 是一个扩展方法。此处是为了体现链式调用的可读性,转而使用扩展方法,没有使用本地函数
.ToPagination(pageCount, pageSize)
.ToArray();

result.Should().HaveCount(2);
result[0].Should().Equal(0, 1);
result[1].Should().Equal(2);

/**
* 初始化各数据源数据,各个数据源均有一些数据
*/
memoryData = new[] {0, 1, 2};
redisData = new[] {3, 4, 5};
elasticSearchData = new[] {6, 7, 8};
databaseData = Enumerable.Range(9, 100).ToArray();

var result2 = GetSourceData()
.ToPagination(pageCount, pageSize)
.ToArray();

result2.Should().HaveCount(5);
result2[0].Should().Equal(0, 1);
result2[1].Should().Equal(2, 3);
result2[2].Should().Equal(4, 5);
result2[3].Should().Equal(6, 7);
result2[4].Should().Equal(8, 9);

IEnumerable<int> GetSourceData()
{
// 将多数据源的数据连接在一起
var data = GetDataSource()
.SelectMany(x => x);
return data;

// 获取数据源
IEnumerable<IEnumerable<int>> GetDataSource()
{
// 将数据源依次返回
yield return GetFromMemory();
yield return GetFromRedis();
yield return GetFromElasticSearch();
yield return GetFromDatabase();
}

IEnumerable<int> GetFromMemory()
{
_testOutputHelper.WriteLine("正在从内存中获取数据");
return memoryData;
}

IEnumerable<int> GetFromRedis()
{
_testOutputHelper.WriteLine("正在从Redis中获取数据");
return redisData;
}

IEnumerable<int> GetFromElasticSearch()
{
_testOutputHelper.WriteLine("正在从ElasticSearch中获取数据");
return elasticSearchData;
}

IEnumerable<int> GetFromDatabase()
{
_testOutputHelper.WriteLine("正在从数据库中获取数据");
return databaseData;
}
}

/**
* 值得注意的是:
* 由于 Enumerable 按需迭代的特性,如果将 result2 的所属页数改为只获取 1 页。
* 则在执行数据获取时,将不会再控制台中输出从 Redis、ElasticSearch和数据库中获取数据。
* 也就是说,并没有执行这些操作。读者可以自行修改以上代码,加深印象。
*/
}
}

public static class EnumerableExtensions
{
/// <summary>
/// 将原数据分页
/// </summary>
/// <param name="source">数据源</param>
/// <param name="pageCount">页数</param>
/// <param name="pageSize">页大小</param>
/// <returns></returns>
public static IEnumerable<IEnumerable<int>> ToPagination(this IEnumerable<int> source,
int pageCount,
int pageSize)
{
var maxCount = pageCount * pageSize;
var countNow = 0;
var onePage = new LinkedList<int>();
foreach (var i in source)
{
onePage.AddLast(i);
countNow++;

// 如果获取的数量已经达到了分页所需要的总数,则停止进一步迭代
if (countNow == maxCount)
{
break;
}

if (onePage.Count != pageSize)
{
continue;
}

yield return onePage;
onePage = new LinkedList<int>();
}

// 最后一页如果数据不足一页,也应该返回该页
if (onePage.Count > 0)
{
yield return onePage;
}
}
}
}

源码说明

以上示例的源代码放置于博客示例代码库中。

项目采用 netcore 2.2 作为目标框架,因此需要安装 netcore 2.2 SDK 才能运行。