Tree Enumerator

   
 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

public class Tree<TItem> : IEnumerable<TItem> where TItem : IComparable<TItem> {
    public Tree(TItem nodeValue) {
        this.NodeData = nodeValue;
        this.LeftTree = null;
        this.RightTree = null;
    }

    public void Insert(TItem newItem) {
        TItem currentNodeValue = this.NodeData;
        if (currentNodeValue.CompareTo(newItem) > 0) {
            if (this.LeftTree == null) {
                this.LeftTree = new Tree<TItem>(newItem);
            } else {
                this.LeftTree.Insert(newItem);
            }
        } else {
            if (this.RightTree == null) {
                this.RightTree = new Tree<TItem>(newItem);
            } else {
                this.RightTree.Insert(newItem);
            }
        }
    }

    public void WalkTree() {
        if (this.LeftTree != null) {
            this.LeftTree.WalkTree();
        }

        Console.WriteLine(this.NodeData.ToString());

        if (this.RightTree != null) {
            this.RightTree.WalkTree();
        }
    }

    public TItem NodeData { get; set; }
    public Tree<TItem> LeftTree { get; set; }
    public Tree<TItem> RightTree { get; set; }


    IEnumerator<TItem> IEnumerable<TItem>.GetEnumerator() {
        return new TreeEnumerator<TItem>(this);
    }
    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() {
        throw new NotImplementedException();
    }


}

class TreeEnumerator<T> : IEnumerator<T> where T : IComparable<T> {
    public TreeEnumerator(Tree<T> data) {
        this.currentData = data;
    }

    private void populate(Queue<T> enumQueue, Tree<T> tree) {
        if (tree.LeftTree != null) {
            populate(enumQueue, tree.LeftTree);
        }

        enumQueue.Enqueue(tree.NodeData);

        if (tree.RightTree != null) {
            populate(enumQueue, tree.RightTree);
        }
    }

    private Tree<T> currentData = null;
    private T currentItem = default(T);
    private Queue<T> enumData = null;

    T IEnumerator<T>.Current {
        get {
            if (this.enumData == null)
                throw new InvalidOperationException("Use MoveNext before calling Current");

            return this.currentItem;
        }
    }
    void IDisposable.Dispose() {
        // throw new NotImplementedException();
    }
    object System.Collections.IEnumerator.Current {
        get { throw new NotImplementedException(); }
    }
    bool System.Collections.IEnumerator.MoveNext() {
        if (this.enumData == null) {
            this.enumData = new Queue<T>();
            populate(this.enumData, this.currentData);
        }

        if (this.enumData.Count > 0) {
            this.currentItem = this.enumData.Dequeue();
            return true;
        }
        return false;
    }
    void System.Collections.IEnumerator.Reset() {
        throw new NotImplementedException();
    }
}

class Program {
    static void Main(string[] args) {
        Tree<int> tree1 = new Tree<int>(10);
        tree1.Insert(5);
        tree1.Insert(11);
        tree1.Insert(5);
        tree1.Insert(-12);
        tree1.Insert(15);
        tree1.Insert(0);
        tree1.Insert(14);
        tree1.Insert(-8);
        tree1.Insert(10);

        foreach (int item in tree1)
            Console.WriteLine(item);
    }
}