试试 IEnumerable 的另外 6 个小例子
2024-08-30 01:42:52
IEnumerable 接口是 C# 开发过程中非常重要的接口，对于其特性和用法的了解是十分必要的。本文将通过6个小例子，来熟悉一下其简单的用法。
<!-- more -->
阅读建议
- 在阅读本篇时，建议先阅读前篇《试试IEnumerable的10个小例子》，更加助于读者理解。
- 阅读并理解本篇需要花费5-10分钟左右的时间，而且其中包含一些实践建议。建议先收藏本文，闲时阅读并实践。
全是源码
以下便是这6个小例子，相应的说明均标记在注释中。
每个以 TXX 开头命名的均是一个示例。建议从上往下阅读。
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[] {, , , , };
var array2 = new[] {, , , , }; // 通过本地方法合并两个数组为一个数据
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(, ).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(, , )
.ToArray(); /**
* 与 GetSomeData 方法对比，将“遍历”和“处理”两个逻辑进行了分离。
* “遍历”指的是三重循环本身。
* “处理”指的是三重循环最内部的加法过程。
* 这里通过 Select 方法，将“处理”过程抽离了出来。
* 这其实和 “T03分离条件”中使用 Where 使用的是相同的思想。
*/
var result2 = GetSomeData2(, , )
.Select(tuple => tuple.i * + tuple.j * + tuple.k)
.ToArray(); // 生成一个 0-999 的数组。
var result = Enumerable.Range(, ).ToArray(); result1.Should().Equal(result);
result2.Should().Equal(result); IEnumerable<int> GetSomeData(int maxI, int maxJ, int maxK)
{
for (var i = ; i < maxI; i++)
{
for (var j = ; j < maxJ; j++)
{
for (var k = ; k < maxK; k++)
{
yield return i * + j * + k;
}
}
}
} IEnumerable<(int i, int j, int k)> GetSomeData2(int maxI, int maxJ, int maxK)
{
for (var i = ; i < maxI; i++)
{
for (var j = ; j < maxJ; j++)
{
for (var k = ; 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 = ,
Children = new[]
{
new TreeNode
{
Value = ,
Children = new[]
{
new TreeNode
{
Value =
},
}
},
new TreeNode
{
Value =
},
}
}; // 深度优先遍历的结果
var dftResult = new[] {, , , }; // 通过迭代器实现深度优先遍历
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[] {, , , }; /**
* 通过迭代器实现广度优先遍历
* 此处未提供“通过队列配合循环算法”和“递归算法”实现广度优先遍历的两种算法进行对比。读者可以自行尝试。
*/
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 = ,
Children = new[]
{
new TreeNode
{
Value = ,
Children = new[]
{
new TreeNode
{
Value =
},
}
},
new TreeNode
{
Value = ,
Children = new[]
{
new TreeNode
{
Value =
},
}
},
}
}; /**
* 有了深度优先遍历算法的情况下，再增加一个条件判断，便可以实现深度优先的搜索
* 搜索树中第一个大于等于 3 并且是奇数的数字
*/
var result = DFS(tree, x => x >= && x % == ); /**
* 搜索到的结果是3。
* 特别提出，如果使用广度优先搜索，结果应该是5。
* 读者可以通过 T13遍历树 中的广度优先遍历算法配合 FirstOrDefault 中相同的条件实现。
* 建议读者尝试以上代码尝试一下。
*/
result.Should().Be(); 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[] {, , , , , , , , , }; // 使用迭代器进行分页，每 3 个一页
var enumerablePagedResult = PageByEnumerable(arraySource, ).ToArray(); // 结果一共 4 页
enumerablePagedResult.Should().HaveCount();
// 最后一页只有一个数字，为 9
enumerablePagedResult.Last().Should().Equal(); // 通过常规的 Skip 和 Take 来分页是最为常见的办法。结果应该与上面的分页结果一样
var result3 = NormalPage(arraySource, ).ToArray(); result3.Should().HaveCount();
result3.Last().Should().Equal(); 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 > )
{
yield return onePage;
}
} IEnumerable<IEnumerable<int>> NormalPage(IReadOnlyCollection<int> source, int pageSize)
{
var pageCount = Math.Ceiling(1.0 * source.Count / pageSize);
for (var i = ; 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 = ;
const int pageCount = ;
var emptyData = Enumerable.Empty<int>().ToArray(); /**
* 初始化各数据源的数据，除了内存有数据外，其他数据源均没有数据
*/
var memoryData = new[] {, , };
var redisData = emptyData;
var elasticSearchData = emptyData;
var databaseData = emptyData; var result = GetSourceData()
// ToPagination 是一个扩展方法。此处是为了体现链式调用的可读性，转而使用扩展方法，没有使用本地函数
.ToPagination(pageCount, pageSize)
.ToArray(); result.Should().HaveCount();
result[].Should().Equal(, );
result[].Should().Equal(); /**
* 初始化各数据源数据，各个数据源均有一些数据
*/
memoryData = new[] {, , };
redisData = new[] {, , };
elasticSearchData = new[] {, , };
databaseData = Enumerable.Range(, ).ToArray(); var result2 = GetSourceData()
.ToPagination(pageCount, pageSize)
.ToArray(); result2.Should().HaveCount();
result2[].Should().Equal(, );
result2[].Should().Equal(, );
result2[].Should().Equal(, );
result2[].Should().Equal(, );
result2[].Should().Equal(, ); 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 = ;
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 > )
{
yield return onePage;
}
}
}
}
源码说明
以上示例的源代码放置于博客示例代码库中。
项目采用 netcore 2.2 作为目标框架，因此需要安装 netcore 2.2 SDK 才能运行。
- 本文作者： Newbe36524
- 本文链接： http://www.newbe.pro/2019/09/10/Others/Try-More-On-IEnumerable-2/
- 版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
最新文章
- javascript中的窗口和框架
- c#调用Mysql带参数的存储过程
- coreseek实战(三)：全文搜索在php中应用（使用api接口）
- 让C程序更高效的10种方法（转）
- 《TCP/IP详解卷1：协议》第17、18章 TCP：传输控制协议（2）-读书笔记
- 创建sh文件
- jsp弹出Please check the location and try again！对话框
- Drupal常用开发工具（一）——Devel模块
- 如何自定义Liferay 7 portal的Log in登录界面
- Unity 梯子生成算法
- javascript单元测试(转)
- 使用API创建AR 贷项通知单
- infiniband学习总结
- 封装自己的Ajax框架
- Ubuntu下 jdk环境变量设置
- SpringCloud是什么？
- 熟悉Python的各种基础小算法
- Linux运维小知识
- 【Java每日一题】20170301
- BZOJ2038[2009国家集训队]小Z的袜子(hose)——莫队