The first example iterates two collections simultaneously:

using System;
using System.Collections.Generic;

namespace Donis.CSharpBook {
    public class Starter {
        public static void Main() {
            ZClass obj = new ZClass();
            foreach (int item in obj) {
                Console.Write(item);
            }
        }
    }

    public class ZClass {

        private int[] list1 = new int[] {0,2,4,6,8};
        private int[] list2 = new int[] {1,3,5,7,9};

        public IEnumerator<int> GetEnumerator() {
            for (int index = 0; index < 5; ++index) {
                yield return list1[index];
                yield return list2[index];
            }
        }
    }
}

The preceding code alternates between yielding list1 and list2. As the iteration moves between collections, the even and odd numbers are intermixed. The result is 0123456789. ZClass does not inherit the IEnumerable interface. However, it adheres to the enumerator pattern by implementing the GetEnumerator method. This is sufficient for an iterator.

The following example iterates a collection forward and in reverse. Two iterators are exposed for this reason. GetEnumerator exposes the standard forward iterator. The reverse iterator is implemented in the Reverse property. Because the property returns IEnumerable, the Reverse property is both an enumerable and an enumerator object. When an iterator method returns IEnumerable, the nested class generated by the compiler is implemented as both an enumerable and an enumerator object. In Main, there are two foreach loops: The first foreach loop uses the forward iterator, whereas the reverse iterator is requested in the second loop:

using System;
using System.Collections.Generic;

namespace Donis.CSharpBook {
    public class Starter {
        public static void Main() {
            Console.WriteLine("Forward List");
            ZClass obj = new ZClass();
            foreach (int item in obj) {
                Console.Write(item);
            }
            Console.WriteLine("
Reverse List");
            foreach (int item in obj.Reverse) {
                Console.Write(item);
            }
        }
    }

    public class ZClass {

        private int[] list1 = new int[] {0,2,4,6,8};

        public IEnumerator<int> GetEnumerator() {
            for (int index = 0; index < 5; ++index) {
                yield return list1[index];
            }
        }

        public IEnumerable<int> Reverse {
            get {
                for (int index = 4; index >= 0; --index) {
                   yield return list1[index];
                }
            }
        }
    }
}

Temporary collections are calculated at run time and are useful in a variety of circumstances. The list of prime numbers, the records of a file, and fields in a dataset are examples of collections that can be calculated. Temporary collections can be populated lazily. You can read a flat file or dataset on demand at run time to hydrate a temporary collection.

The following code enumerates days from the current date until the end of the month, which is calculated using the DateTime structure. The method ToEndOfMonth is enumerable by virtue of the fact that it returns the IEnumerable interface and includes a yield statement. Each iteration of the while loop extrapolates the next day until the end of the month is reached. The yield statement iterates the days as they are calculated:

using System;
using System.Collections;

namespace Donis.CSharpBook {
    public class Starter {
        public static void Main() {
            foreach (string day in ToEndOfMonth()) {
                Console.WriteLine(day);
            }
        }

        public static IEnumerable ToEndOfMonth() {
            DateTime date = DateTime.Now;
            int currMonth = date.Month;
            while (currMonth == date.Month) {
                string temp = currMonth.ToString() +
                    "/" + date.Day.ToString();
                date = date.AddDays(1);
                yield return temp;
            }
        }
    }
}

Iterators are particularly useful when iterating complex data structures, such as linked lists. Each item in the list is considered a node. Each node maintains a reference to the previous and the next node. From any node, you can walk the linked list either forward or backward. The iteration is more complex for several reasons. First, the linked list can be iterated forward and backward during the same iteration. Second, fenceposts are less obvious than in other data structures. Fenceposts in arrays, stacks, queues, and other sequenced containers are found easily, which helps avoid fencepost error exceptions. Finally, the iteration can start from any node in the linked list, not necessarily just at the beginning or end. For example, if the iteration starts in the middle of the linked list, how do you enumerate all the nodes?

The following code gives a partial listing of the Node class. The key portion of the code is in the GetEnumerator method. In the first while loop, the linked list is iterating in reverse—from the current node to the beginning of the list. This is accomplished by walking the prevNode member of the node class. The current node is enumerated next. Finally, the second while loop iterates the linked list going forward from the current note to the end of the list by walking the nextNode members:

public class Node<T> {

    public Node(Node<T> node, T data) {
        m_Info = data;
        if (node == null) {
            if (firstNode != null) {
                 Node<T> temp = firstNode;
                 this.nextNode = temp;
                 this.prevNode = null;
                 temp.prevNode = this;
                 firstNode = this;
                 return;
             }
             prevNode = null;
             nextNode = null;
             firstNode = this;
             lastNode = this;
             return;
        }

        this.prevNode = node;
        this.nextNode = node.nextNode;
        node.nextNode = this;
        if (this.nextNode == null) {
            lastNode = this;
        }
        else {
            this.nextNode.prevNode = this;
        }
    }

    public void AddNode(T data) {
        this.nextNode = new Node<T>(this, data);
    }

    public IEnumerator<T> GetEnumerator () {
        Node<T> temp = prevNode;
        while (temp != null) {
            yield return temp.m_Info;
            temp = temp.prevNode;
        }
        yield return m_Info;
        temp = nextNode;
        while (temp != null) {
            yield return temp.m_Info;
            temp = temp.nextNode;
        }
    }

    private T m_Info;
    private static Node<T> lastNode = null;
    private static Node<T> firstNode = null;
    private Node<T> prevNode = null;
    private Node<T> nextNode = null;
}