IEnumerable的小例子有哪些
今天就跟大家聊聊有关 IEnumerable 的小例子有哪些，可能很多人都不太了解，为了让大家更加了解，小编给大家总结了以下内容，希望大家根据这篇文章可以有所收获。
成都创新互联是专业的东昌府网站建设公司，东昌府接单;提供成都网站建设、做网站,网页设计,网站设计,建网站,PHP网站建设等专业做网站服务;采用PHP框架,可快速的进行东昌府网站开发网页制作和功能扩展;专业做搜索引擎喜爱的网站,专业的做网站团队,希望更多企业前来合作!
全是源码
每个以 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[] {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 ConcatArray(IEnumerable source1, IEnumerable 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 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();
}
///
/// 当前节点的值
///
public int Value { get; set; }
///
/// 当前节点的子节点列表
///
public IEnumerable 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 DFTByEnumerable(TreeNode root)
{
yield return root.Value;
foreach (var child in root.Children)
{
foreach (var item in DFTByEnumerable(child))
{
yield return item;
}
}
}
// 使用堆栈配合循环算法实现深度优先遍历
IEnumerable DFTByStack(TreeNode root)
{
var result = new List();
var stack = new Stack();
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 DFTByRecursion(TreeNode root)
{
var list = new List {root.Value};
foreach (var rootChild in root.Children)
{
list.AddRange(DFTByRecursion(rootChild));
}
return list;
}
// 通过迭代器实现广度优先遍历
IEnumerable BFT(TreeNode root)
{
yield return root.Value;
foreach (var bftChild in BFTChildren(root.Children))
{
yield return bftChild;
}
IEnumerable BFTChildren(IEnumerable children)
{
var tempList = new List();
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 predicate)
{
var re = DFTByEnumerable(root)
.FirstOrDefault(predicate);
return re;
}
// 迭代器深度优先遍历
IEnumerable 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> PageByEnumerable(IEnumerable source, int pageSize)
{
var onePage = new LinkedList();
foreach (var i in source)
{
onePage.AddLast(i);
if (onePage.Count != pageSize)
{
continue;
}
yield return onePage;
onePage = new LinkedList();
}
// 最后一页如果数据不足一页，也应该返回该页
if (onePage.Count > 0)
{
yield return onePage;
}
}
IEnumerable> NormalPage(IReadOnlyCollection 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().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 GetSourceData()
{
// 将多数据源的数据连接在一起
var data = GetDataSource()
.SelectMany(x => x);
return data;
// 获取数据源
IEnumerable> GetDataSource()
{
// 将数据源依次返回
yield return GetFromMemory();
yield return GetFromRedis();
yield return GetFromElasticSearch();
yield return GetFromDatabase();
}
IEnumerable GetFromMemory()
{
_testOutputHelper.WriteLine("正在从内存中获取数据");
return memoryData;
}
IEnumerable GetFromRedis()
{
_testOutputHelper.WriteLine("正在从Redis中获取数据");
return redisData;
}
IEnumerable GetFromElasticSearch()
{
_testOutputHelper.WriteLine("正在从ElasticSearch中获取数据");
return elasticSearchData;
}
IEnumerable GetFromDatabase()
{
_testOutputHelper.WriteLine("正在从数据库中获取数据");
return databaseData;
}
}
/**
* 值得注意的是：
* 由于 Enumerable 按需迭代的特性，如果将 result2 的所属页数改为只获取 1 页。
* 则在执行数据获取时，将不会再控制台中输出从 Redis、ElasticSearch和数据库中获取数据。
* 也就是说，并没有执行这些操作。读者可以自行修改以上代码，加深印象。
*/
}
}
public static class EnumerableExtensions
{
///
/// 将原数据分页
///
/// 数据源
/// 页数
/// 页大小
/// > ToPagination(this IEnumerable source,
int pageCount,
int pageSize)
{
var maxCount = pageCount * pageSize;
var countNow = 0;
var onePage = new LinkedList();
foreach (var i in source)
{
onePage.AddLast(i);
countNow++;
// 如果获取的数量已经达到了分页所需要的总数，则停止进一步迭代
if (countNow == maxCount)
{
break;
}
if (onePage.Count != pageSize)
{
continue;
}
yield return onePage;
onePage = new LinkedList();
}
// 最后一页如果数据不足一页，也应该返回该页
if (onePage.Count > 0)
{
yield return onePage;
}
}
}
} 看完上述内容，你们对 IEnumerable 的小例子有哪些有进一步的了解吗？如果还想了解更多知识或者相关内容，请关注创新互联行业资讯频道，感谢大家的支持。
本文题目：IEnumerable的小例子有哪些
文章起源：http://ybzwz.com/article/pdoege.html
