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[] {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 才能執行。

• 本文作者： Newbe36524
• 本文連結： http://www.newbe.pro/2019/09/10/Others/Try-More-On-IEnumerable-2/
• 版權宣告： 本部落格所有文章除特別宣告外，均採用 BY-NC-SA 許可協議。轉載請