試試 IEnumerable 的另外 6 個小例子

時間 2019-11-10
標籤試試 ienumerable 另外例子简体版
原文原文鏈接
IEnumerable 接口是 C# 開發過程當中很是重要的接口，對於其特性和用法的瞭解是十分必要的。本文將經過6個小例子，來熟悉一下其簡單的用法。node
git
閱讀建議

在閱讀本篇時，建議先閱讀前篇《試試IEnumerable的10個小例子》，更加助於讀者理解。
閱讀並理解本篇須要花費5-10分鐘左右的時間，並且其中包含一些實踐建議。建議先收藏本文，閒時閱讀並實踐。
全是源碼

如下即是這6個小例子，相應的說明均標記在註釋中。github
每一個以 TXX 開頭命名的均是一個示例。建議從上往下閱讀。redis
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;
            }
        }
    }
}