あなたの知らないC#トラップ、IEnumerableインターフェースのサンプルコードを詳しく解説

あなたの知らない C# トラップ、IEnumerable インターフェイスのサンプル コードの詳細な説明:

IEnumerable 列挙子インターフェイスの重要性は、1 万語で強調しすぎることはできません。ほとんどすべてのコレクションがこのインターフェイスを実装しており、Linq のコアもこのユニバーサル インターフェイスに依存しています。 C言語のforループは書くのが面倒ですが、foreachの方がずっとスムーズです。

私はこのインターフェイスがとても気に入っていますが、使用中にたくさんの疑問に遭遇しました:

(1) IEnumerable と IEnumerator の違いは何ですか

(2) 列挙関数国境を越えたアクセスがない場合、どのような影響がありますか?列挙型でコレクションの値を変更できないのはなぜですか?

(3) Linq の具体的な実装は何ですか? たとえば、Skip はいくつかの要素にアクセスしましたか? (4) IEnumerable の本質とは何ですか?

(5) IEnumerable 列挙型で

クロージャ

が形成されますか?複数の列挙プロセスは相互に干渉しますか?列挙内で列挙の要素を動的に変更できますか? ….

ご興味がございましたら、以下の内容で続けていきます。

始める前に、この記事では、列挙は IEnumerable、反復は IEnumerator、インスタンス化された (ToList() など) はコレクションであると規定しています。

1. IEnumerable と IEnumerator

IEnumerable には GetEnumerator() という 1 つの抽象メソッドがあり、IEnumerator はコレクションにアクセスする機能を真に実現するイテレーターです。 IEnumerator には、Current プロパティが 1 つだけと、MoveNext と Reset の 2 つのメソッドがあります。

アクセサーインターフェイスを構築するだけでは十分ではないでしょうか?混乱して見える 2 つのインターフェイスがあるのはなぜでしょうか? 1 つは列挙子と呼ばれ、もう 1 つはイテレータと呼ばれます。

(1) IEnumerator の実装は、2 つのメソッドと 1 つの属性を無駄に追加するという汚い仕事であり、これら 2 つのメソッドは実際には実装するのが簡単ではありません (後述)。

(2) 初期状態を維持し、MoveNext の方法、終了方法を知る必要があり、同時に

反復の前の状態を返す

必要がありますが、これは簡単ではありません。 (3) 反復は明らかにスレッドセーフではありません。各 IEnumerable は新しい IEnumerator を生成するため、相互に影響を及ぼさない複数の反復プロセスが形成されます。反復プロセス中は反復コレクションを変更できません。変更しないと安全ではありません。

つまり、IEnumerable を実装している限り、コンパイラーは IEnumerator の実装を支援します。さらに、ほとんどの場合、それらは既存のコレクションから継承されるため、通常、MoveNext メソッドと Reset メソッドをオーバーライドする必要はありません。もちろん、IEnumerable には一般的な実装もありますが、これはこの問題の議論には影響しません。

IEnumerable は、C では、次のノードの情報を保存するためにポインター フィールドが必要であることを思い出させます。では、IEnumerable では、この情報を保存するのは誰でしょうか?このプロセスはメモリを消費しますか? プログラム領域やヒープ領域を占有しているのでしょうか？

ただし、IEnumerable にも欠点があり、戻ることもジャンプすることもできず (1 つずつジャンプすることしかできません)、Reset の実装は簡単ではなく、インデックス アクセスも実現できません。考えてみてください。インスタンスのコレクションの列挙処理であれば、直接 0 番目の要素に戻るだけですが、この IEnumerable が長いアクセス チェーンである場合、元のルートを見つけるのは非常に困難になります。したがって、C# による CLR の作成者は、実際には、多くの Reset 実装は単なる嘘であることを知っておいて、あまり依存しないでくださいと述べています。

2. foreach と MoveNext には違いがありますか?

IEnumerable の最大の特徴は、アクセスプロセスを訪問者自身の制御下に置くことです。 C 言語では、配列制御は完全に外部にあります。このインターフェイスはアクセス プロセスを内部でカプセル化し、カプセル化をさらに改善します。例:

public class People  //定义一个简单的实体类
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }

    public class PersonList
    {
        private readonly List<People> peoples;

        public PersonList()  //为了方便，构造过程中插入元素
        {
            peoples = new List<People>();
            for (int i = 0; i < 5; i++)
            {
                peoples.Add(new People {Name = "P" + i, Age = 30 + i});
            }
        }

        public int OldAge = 31;
        public IEnumerable<People> OlderPeoples
        {
            get
            {
                foreach (People people in _people)
                {
                    if (people.Age > OldAge)
                        yield return people;
                }
                yield break;
            }
        }
    }

IEnumerable の本質は、イベントの概念に似ており、Linq の基礎であるコード間の移動

(星間移動を考えてください) を実現します。クールなイテレーターは本当に私たちが思っているほど単純なのでしょうか? C 言語では、配列は配列、つまり実メモリ空間です。では、IEnumerable とは何を意味しますか?実際のコレクション (List など) で実装されている場合は問題ありません。これも実メモリですが、上記の例の場合はどうでしょうか。フィルタリングによって返される yield return は要素のみを返しますが、この実際のコレクションは存在しない可能性があります。単純な列挙子の yield return を逆コンパイルすると、それが実際には一連の switch-case であり、コンパイラが で動作していることがわかります。私たちのためにたくさんの仕事をしてくれました。

MoveNext が使用されていない場合、生成された新しいイテレーターは実際には空です。これはなぜですか?イテレータが head 要素を直接指さないのはなぜですか?

(回答ありがとうございます: C 言語の一方向リンクリストのヘッドポインタと同じように、要素を含まない列挙型を指定できるため、プログラミングがより便利になります)

foreach はスペース 1 つずつ前に進みます。時間は終わります、やめてください。 待って、終わると本当に止まりますか？実験してみましょう:

public IEnumerable<People> Peoples1   //直接返回集合
        {
            get { return peoples; }
        }public IEnumerable<People> Peoples2  //包含yield break;
        {
            get
            {
                foreach (var people in peoples)
                {
                    yield return people;
                }
                yield break;  //其实这个用不用都可以
            }
        }

上記の 2 つは一般的なメソッドです。2 番目の実装では、ReSharper がイールド ブレークを灰色 (重複) でマークしていることに注意してください。

我们再写下如下的测试代码，peopleList集合只有五个元素，但尝试去MoveNext 8次。可以把peopleList.Peoples1换成2,3，分别测试。

            var peopleList = new PeopleList();  //内部构造函数插入了五个元素
            IEnumerator<People> e1 = peopleList.Peoples1.GetEnumerator();
            if (e1.Current == null)
            {
                Console.WriteLine("迭代器生成后Current为空");
            }
            int i = 0;
            while (i<8)  //总共只有五个元素，看看一直迭代会发生什么效果
            {
                e1.MoveNext();
                if (e1.Current == null)
                {
                    Console.WriteLine("迭代第{0}次后为空",i);
                }
                else
                {
                    Console.WriteLine("迭代第{0}次后为{1}",i,e1.Current.Name);
                }
                i++;
            }

//PeopleEnumerable1   (直接返回集合)
迭代器生成后Current为空
迭代第0次后为P0
迭代第1次后为P1
迭代第2次后为P2
迭代第3次后为P3
迭代第4次后为P4
迭代第5次后为空
迭代第6次后为空
迭代第7次后为空

//PeopleEnumerable2 （不加yield break）
迭代器生成后Current为空
迭代第0次后为P0
迭代第1次后为P1
迭代第2次后为P2
迭代第3次后为P3
迭代第4次后为P4
迭代第5次后为P4
迭代第6次后为P4
迭代第7次后为P4

//PeopleEnumerable2 （加上yield break）
迭代器生成后Current为空
迭代第0次后为P0
迭代第1次后为P1
迭代第2次后为P2
迭代第3次后为P3
迭代第4次后为P4
迭代第5次后为P4
迭代第6次后为P4
迭代第7次后为P4

越界枚举测试结果

真让人吃惊，返回原始集合，越界之后就返回null了，但如果是MoveNext，不论有没有加yield break, 越界迭代后还是返回最后一个元素！ 也许就是我们在第1节里提到的，迭代器只返回上一次的状态，因为无法后移，所以就重复返回，那为什么List集合就不会这样呢？问题留给大家。

（感谢回答：越界枚举到底是null还是最后一个元素的问题，其实没有明确规定，具体看.NET的实现，在.NET Framework中，越界后依然是最后一个元素）。

不过各位看官尽管放心，在foreach的标准枚举过程下，枚举是肯定能枚举完的，这就说明了MoveNext和foreach两种在实现上的不同，显然foreach更安全。同时还注意，不能在yield过程中实现try-catch代码块，为什么呢？因为yield模式组合了来自不同位置的代码和逻辑，怎么可能靠编译给每个引用的代码块加上try-catch？这太复杂了。

枚举的特性在处理大数据的时候很有帮助，就是因为它的状态性，一个超大的文件，我只要每次读一部分，就可以顺次的读取下去，直到文件结束，由于不需要实例化集合，内存占用是很低的。对数据库也是如此，每次读取一部分，就能应对很多难以应付的情况。

3.在枚举中修改枚举器参数？

在枚举过程中，集合是不能被修改的，比如在foreach循环中，如果插入或者删除一个元素，肯定会报运行时异常。有经验的程序员告诉 你，此时用for循环。for和foreach的本质区别是什么呢？

在MoveNext中，我突然改变了枚举的参数，使得它的数据量变多或者变少了，又会发生什么？

           Console.WriteLine("不修改OldAge参数");
            foreach (var olderPeople in peopleList.OlderPeoples)
            {
                Console.WriteLine(olderPeople);

            }

            Console.WriteLine("修改了OldAge参数");
            i = 0;
            foreach (var olderPeople in peopleList.OlderPeoples)
            {
                Console.WriteLine(olderPeople);
                i++;
                if (i ==1)
                    peopleList.OldAge = 33;  //只枚举一次后，修改OldAge 的值
            }

测试结果是：

不修改OldAge参数
ID:2,NameP2,Age32
ID:3,NameP3,Age33
ID:4,NameP4,Age34

修改了OldAge参数
ID:2,NameP2,Age32
ID:4,NameP4,Age34

可以看到，在枚举过程中修改了控制枚举的值，能动态改变枚举的行为。上面是在一个yield结构中改变变量的情况，我们再试试在迭代器和Lambda表达式的情况（代码略）， 得到结果是：

在迭代中修改变量值
ID:2,NameP2,Age32
ID:4,NameP4,Age34
在Lambda表达式中修改变量值
ID:2,NameP2,Age32
ID:4,NameP4,Age34

可以看出，外部修改变量能够控制内部的迭代过程，动态改变了“集合的元素”。 这是一个好事，因为它的行为确实是对的；也是坏事：在迭代过程中，修改了变量的值，上下文语境变化，可是如果还按之前的语境进行处理，显然就会酿成大错。 这里和闭包没关系。

因此，如果一个枚举需要在上下文会发生变化的情况下保持原有的行为，就需要手动保存变量的副本。

如果你把两个集合A,B用Concat函数顺次拼接起来，也就是A-B, 而且不实例化，那么在枚举A的阶段中，修改集合B的元素，会报错么？ 为什么？

比如如下的测试代码：

　　　　　　　List<People> peoples=new List<People>(){new People(){Name = "PA"}};
            Console.WriteLine("将一个虚拟枚举A连接到集合B，并在枚举A阶段修改集合B的元素");
            var e8 = peopleList.PeopleEnumerable1.Concat(peoples);
            i = 0;
            foreach (var people in e8)
            {
                Console.WriteLine(people);
                i++;
                if (i == 1)   
                  peoples.Add(new People(){Name = "PB"});  //此时还在枚举PeopleEnumerable1阶段

　　　　　　　　}

如果你想知道，可以自己做个试验（在我附件里也有这个例子）。留给大家讨论。

4. 更多LINQ的讨论

你可以在yield中插入任何代码，这就是延迟（Lazy）的表现，只是需要执行的时候才执行。 我们不难想象Linq很多函数的实现方式，比较有意思的包括Concat,它将两个集合连在了一起，就像下面这样：

public static IEnumerable<T> Concat<T>(this IEnumerable<T> source, IEnumerable<T> source2)
       {
           foreach (var r in source)
           {
               yield return r;
           }
           foreach (var r in source2)
           {
               yield return r;
           }
       }

还有Select, Where都好实现，就不讨论了。

Skip怎么实现的呢？  它跳过了集合中的一部分元素，我猜是这样的：

public static IEnumerable<T> Skip<T>(this IEnumerable<T> source, int count)
       {
           int t = 0;
           foreach (var r in source)
           {
               t++;
               if(t<=count)
                   continue;
               yield return r;
           }
       }

那么，被跳过的元素，到底被访问过没有？它的代码被执行了么？

 Console.WriteLine("Skip的元素是否会被访问到？");
 IEnumerable<People> e6 = peopleList.PeopleEnumerable1.Select(d =>
       {
              Console.WriteLine(d);
              return d;
       }).Skip(3);
 Console.WriteLine("只枚举，什么都不做：");
 foreach (var  r in e6){}  
 Console.WriteLine("转换为实体集合，再次枚举");
 IEnumerable<People> e7 = e6.ToList();
 foreach (var r in e7){}

测试结果如下：

只枚举，什么都不做：
ID:0,NameP0,Age30
ID:1,NameP1,Age31
ID:2,NameP2,Age32
ID:3,NameP3,Age33
ID:4,NameP4,Age34
转换为实体集合，再次枚举
ID:0,NameP0,Age30
ID:1,NameP1,Age31
ID:2,NameP2,Age32
ID:3,NameP3,Age33
ID:4,NameP4,Age34

可以看出，Skip虽然是跳过，但还是会“访问”元素的，因此会执行额外的操作，比如lambda表达式，这不论是枚举器还是实体集合都是如此。这个角度说，要优化表达式，应当尽可能在linq中早的Skip和Take，以减少额外的副作用。

但对于Linq to SQL的实现中，显然Skip是做过额外优化的。我们是否也能优化Skip的实现，使得上层尽可能提升海量数据下的Skip性能呢？

5. 有关IEnumerable枚举的更多问题

(1) 枚举过程如何暂停？有暂停这一说么？ 如何取消？

(2) PLinq的实现原理是什么？它改变的到底是IEnumerable接口的哪种特性？是否产生了乱序枚举？这种乱序枚举到底是怎么实现？

(3) IEnumerable实现了链条结构，这是Linq的基础，但这个链条的本质是什么？

(4) IEnumerable はステータスと遅延を表すため、多くの非同期操作の本質が IEnumerable であることを理解するのは難しくありません。あるインタビューで、非同期の本質について質問されました。非同期の本質は何だと思いますか? Async はマルチスレッドではありません。長期にわたる非同期操作はステート マシンであるため、非同期の利点は本質的にコードの再編成にあります。 。 。たとえば、CCR ライブラリです。それについては、一時的に著者の知識の範囲を超えているため、ここでは詳しく説明しません。次回説明します。

(5) 同じ列挙子を C 言語で実装した場合、コンパイラに依存せずに同じクールな Linq を実装できますか? Lambda のトリックについては触れずに、関数ポインターを使用しましょう。

(6) IEnumerable は MapReduce 用の Linq で書かれていますか?

(7) IEnumerable をセットにインスタンス化して並べ替える方法はありますか?非常に大規模な仮想コレクションの場合、どのように最適化すればよいでしょうか?

以上があなたの知らないC#トラップ、IEnumerableインターフェースのサンプルコードを詳しく解説の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。