Beispiel #1
0
        internal static void Share()
        {
            IEnumerable <int> sequence             = Enumerable.Range(0, 5);
            IEnumerator <int> independentIterator1 = sequence.GetEnumerator();
            IEnumerator <int> independentIterator2 = sequence.GetEnumerator();

            independentIterator1.MoveNext(); independentIterator1.Current.WriteLine(); // 0| |
            independentIterator2.MoveNext(); independentIterator2.Current.WriteLine(); //  |0|
            independentIterator1.MoveNext(); independentIterator1.Current.WriteLine(); // 1| |
            IEnumerator <int> independentIterator3 = sequence.GetEnumerator();         //  | |

            independentIterator3.MoveNext(); independentIterator3.Current.WriteLine(); //  | |0
            independentIterator1.MoveNext(); independentIterator1.Current.WriteLine(); // 2| |
            independentIterator2.MoveNext(); independentIterator2.Current.WriteLine(); //  |1|
            // ...

            IBuffer <int>     share           = Enumerable.Range(0, 5).Share();
            IEnumerator <int> sharedIterator1 = share.GetEnumerator();
            IEnumerator <int> sharedIterator2 = share.GetEnumerator();

            sharedIterator1.MoveNext(); sharedIterator1.Current.WriteLine(); // 0| |
            sharedIterator2.MoveNext(); sharedIterator2.Current.WriteLine(); //  |1|
            sharedIterator1.MoveNext(); sharedIterator1.Current.WriteLine(); // 2| |
            IEnumerator <int> sharedIterator3 = share.GetEnumerator();       //  | |

            sharedIterator3.MoveNext(); sharedIterator3.Current.WriteLine(); //  | |3

            share.Dispose();
            sharedIterator1.MoveNext(); // ObjectDisposedException.
            sharedIterator2.MoveNext(); // ObjectDisposedException.
            sharedIterator3.MoveNext(); // ObjectDisposedException.
        }
Beispiel #2
0
        internal static void DesugaredZipShared()
        {
            IEnumerable <int> source1 = Enumerable.Range(0, 5);

            IEnumerable <(int, int)> Zip1()
            {
                using (IEnumerator <int> independentIterator1 = source1.GetEnumerator())
                    using (IEnumerator <int> independentIterator2 = source1.GetEnumerator())
                    {
                        while (independentIterator1.MoveNext() && independentIterator2.MoveNext())
                        {
                            yield return(independentIterator1.Current, independentIterator2.Current);
                            // Yield (0, 0) (1, 1) (2, 2) (3, 3) (4, 4).
                        }
                    }
            }

            Zip1().WriteLines();

            using (IBuffer <int> source2 = Enumerable.Range(0, 5).Share())
            {
                IEnumerable <(int, int)> Zip2()
                {
                    using (IEnumerator <int> sharedIterator1 = source2.GetEnumerator())
                        using (IEnumerator <int> sharedIterator2 = source2.GetEnumerator())
                        {
                            while (sharedIterator1.MoveNext() && sharedIterator2.MoveNext())
                            {
                                yield return(sharedIterator1.Current, sharedIterator2.Current);
                                // Yield (0, 1) (2, 3).
                            }
                        }
                }

                Zip2().WriteLines();
            }

            IEnumerable <int> source3 = Enumerable.Range(0, 5);

            IEnumerable <(int, int)> Zip3()
            {
                using (IBuffer <int> source = source3.Share())
                    using (IEnumerator <int> sharedIterator1 = source.GetEnumerator())
                        using (IEnumerator <int> sharedIterator2 = source.GetEnumerator())
                        {
                            while (sharedIterator1.MoveNext() && sharedIterator2.MoveNext())
                            {
                                yield return(sharedIterator1.Current, sharedIterator2.Current);
                                // Yield (0, 1) (2, 3).
                            }
                        }
            }

            Zip3().WriteLines();
        }
Beispiel #3
0
        internal static void Publish2()
        {
            IBuffer <int>     publish   = Enumerable.Range(0, 5).Publish();
            IEnumerator <int> iterator1 = publish.GetEnumerator();
            // iterator1: 0 1 2 3 4
            IEnumerator <int> iterator2 = publish.GetEnumerator();

            // iterator1: 0 1 2 3 4
            iterator1.MoveNext(); iterator1.Current.WriteLine(); // 0| |Trace: 0
            iterator1.MoveNext(); iterator1.Current.WriteLine(); // 1| |Trace: 1
            iterator1.MoveNext(); iterator1.Current.WriteLine(); // 2| |Trace: 2
            iterator2.MoveNext(); iterator2.Current.WriteLine(); //  |0|
            iterator1.MoveNext(); iterator1.Current.WriteLine(); // 3| |Trace: 3
            iterator2.MoveNext(); iterator2.Current.WriteLine(); //  |1|
            iterator1.MoveNext(); iterator1.Current.WriteLine(); // 4| |Trace: 4

            publish.Dispose();
            iterator1.MoveNext(); // ObjectDisposedException.
            iterator2.MoveNext(); // ObjectDisposedException.
        }
Beispiel #4
0
 internal static void Publish()
 {
     using (IBuffer <int> publish = Enumerable.Range(0, 5).Publish())
     {
         IEnumerator <int> remainderIteratorA = publish.GetEnumerator();
         // remainderIteratorA: 0 1 2 3 4.                                         A|B|C
         remainderIteratorA.MoveNext(); remainderIteratorA.Current.WriteLine(); // 0| |
         remainderIteratorA.MoveNext(); remainderIteratorA.Current.WriteLine(); // 1| |
         remainderIteratorA.MoveNext(); remainderIteratorA.Current.WriteLine(); // 2| |
         IEnumerator <int> remainderIteratorB = publish.GetEnumerator();        //  | |
         // remainderIteratorB: 3 4.                                                | |
         remainderIteratorB.MoveNext(); remainderIteratorB.Current.WriteLine(); //  |3|
         remainderIteratorA.MoveNext(); remainderIteratorA.Current.WriteLine(); // 3| |
         IEnumerator <int> remainderIteratorC = publish.GetEnumerator();        //  | |
         // remainderIteratorC: 4.                                                  | |
         remainderIteratorB.MoveNext(); remainderIteratorB.Current.WriteLine(); //  |4|
         remainderIteratorA.MoveNext(); remainderIteratorA.Current.WriteLine(); // 4| |
         remainderIteratorC.MoveNext(); remainderIteratorC.Current.WriteLine(); //  | |4
     }
 }
        internal static void Publish()
        {
            IBuffer <int>     publish   = TracedRange(0, 5).Publish();
            IEnumerator <int> iterator1 = publish.GetEnumerator();

            // iterator1: 0 1 2 3 4
            iterator1.MoveNext(); Trace.WriteLine(iterator1.Current); // 0| |Trace: 0
            iterator1.MoveNext(); Trace.WriteLine(iterator1.Current); // 1| |Trace: 1
            iterator1.MoveNext(); Trace.WriteLine(iterator1.Current); // 2| |Trace: 2
            IEnumerator <int> iterator2 = publish.GetEnumerator();    //  | |

            // iterator2: 3 4                                               | |
            iterator2.MoveNext(); Trace.WriteLine(iterator2.Current); //  |3|Trace: 3
            iterator1.MoveNext(); Trace.WriteLine(iterator1.Current); // 3| |
            iterator2.MoveNext(); Trace.WriteLine(iterator2.Current); //  |4|Trace: 4
            iterator1.MoveNext(); Trace.WriteLine(iterator1.Current); // 4| |
                                                                      // Trace: 0 1 2 3 4.

            publish.Dispose();
            iterator1.MoveNext(); // ObjectDisposedException.
            iterator2.MoveNext(); // ObjectDisposedException.
        }
Beispiel #6
0
 internal static void Memoize()
 {
     using (IBuffer <int> memoize = Enumerable.Range(0, 5).Memoize())
     {
         IEnumerator <int> bufferIteratorA = memoize.GetEnumerator();
         // bufferIteratorA: 0 1 2 3 4.                                      A|B|C
         bufferIteratorA.MoveNext(); bufferIteratorA.Current.WriteLine(); // 0| |
         bufferIteratorA.MoveNext(); bufferIteratorA.Current.WriteLine(); // 1| |
         bufferIteratorA.MoveNext(); bufferIteratorA.Current.WriteLine(); // 2| |
         IEnumerator <int> bufferIteratorB = memoize.GetEnumerator();     //  | |
         // bufferIteratorB: 0 1 2 3 4.                                       | |
         bufferIteratorB.MoveNext(); bufferIteratorB.Current.WriteLine(); //  |0|
         bufferIteratorA.MoveNext(); bufferIteratorA.Current.WriteLine(); // 3| |
         IEnumerator <int> bufferIteratorC = memoize.GetEnumerator();     //  | |
         // bufferIteratorC: 0 1 2 3 4.                                       | |
         bufferIteratorB.MoveNext(); bufferIteratorB.Current.WriteLine(); //  |1|
         bufferIteratorA.MoveNext(); bufferIteratorA.Current.WriteLine(); // 4| |
         bufferIteratorC.MoveNext(); bufferIteratorC.Current.WriteLine(); //  | |0
         bufferIteratorC.MoveNext(); bufferIteratorC.Current.WriteLine(); //  | |1
         bufferIteratorB.MoveNext(); bufferIteratorB.Current.WriteLine(); //  |2|
         // ...
     }
 }
Beispiel #7
0
        internal static void DesugaredConcatShared()
        {
            IEnumerable <int> source1 = Enumerable.Range(0, 5);

            IEnumerable <int> Concat1() // source1.Concat(source1)
            {
                using (IEnumerator <int> independentIterator1 = source1.GetEnumerator())
                {
                    while (independentIterator1.MoveNext())
                    {
                        yield return(independentIterator1.Current); // Yield 0 1 2 3 4.
                    }
                }
                using (IEnumerator <int> independentIterator2 = source1.GetEnumerator())
                {
                    while (independentIterator2.MoveNext())
                    {
                        yield return(independentIterator2.Current); // Yield 0 1 2 3 4.
                    }
                }
            }

            Concat1().WriteLines();

            using (IBuffer <int> source2 = Enumerable.Range(0, 5).Share())
            {
                IEnumerable <int> Concat2() // source2.Concat(source2)
                {
                    using (IEnumerator <int> sharedIterator1 = source2.GetEnumerator())
                    {
                        while (sharedIterator1.MoveNext())
                        {
                            yield return(sharedIterator1.Current); // Yield 0 1 2 3 4.
                        }
                    }
                    using (IEnumerator <int> sharedIterator2 = source2.GetEnumerator())
                    {
                        while (sharedIterator2.MoveNext())
                        {
                            yield return(sharedIterator2.Current); // Yield nothing.
                        }
                    }
                }

                Concat2().WriteLines();
            }

            IEnumerable <int> source3 = Enumerable.Range(0, 5);

            IEnumerable <int> Concat3() // source3.Share(source => source.Concat(source))
            {
                using (IBuffer <int> source = source3.Share())
                {
                    using (IEnumerator <int> sharedIterator1 = source.GetEnumerator())
                    {
                        while (sharedIterator1.MoveNext())
                        {
                            yield return(sharedIterator1.Current); // Yield 0 1 2 3 4.
                        }
                    }
                    using (IEnumerator <int> sharedIterator2 = source.GetEnumerator())
                    {
                        while (sharedIterator2.MoveNext())
                        {
                            yield return(sharedIterator2.Current); // Yield nothing.
                        }
                    }
                }
            }

            Concat3().WriteLines();
        }