关于迭代器和泛型的有关问题，小弟我也不知道咋回事求大神帮忙看下

关于迭代器和泛型的问题，我也不知道怎么回事求大神帮忙看下。

    public class Node<T>
    {

        private T data;

        public T Data
        {
            get { return data; }
            set { data = value; }
        }
        private Node<T> lChild;//左孩子

        public  Node<T> LChild
        {
            get { return lChild; }
            set { lChild = value; }
        }
        private Node<T> rChild;//右孩子

        public Node<T> RChild
        {
            get { return rChild; }
            set { rChild = value; }
        }
        public Node(T val, Node<T> lp, Node<T> rp)
        {
            data = val;
            lChild = lp;
            rChild = rp;
        }
        public Node(Node<T> lp, Node<T> rp)
        {
            lChild = lp;
            rChild = rp;
            data = default(T);
        }
        public Node(T val)
        {
            data = val;
            lChild = null;
            rChild = null;
        }
        public Node()
        {
            data = default(T);
            lChild = null;
            rChild = null;
        }
    }

    public class LinkBiTree<T> : IEnumerable<T>
    {
        private Node<T> head;//头引用

        public Node<T> Head
        {
            get { return head; }
            set { head = value; }
        }

        public IEnumerator<T> preOrderTraverese(Node<T> node)
        {
            if (node == null)
                yield break;
            yield return node.Data;
            yield return preOrderTraverese(node.LChild);
            yield return preOrderTraverese(node.RChild);
        }
        public IEnumerator<T> GetEnumerator()
        {
            yield return preOrderTraverese(head);
        }
        public LinkBiTree()
        {
            head = null;
        } 
 
        public LinkBiTree(T val)
        {
            Node<T> p = new Node<T>(val);
            head = p;
        }
        public LinkBiTree(T val, Node<T> lp, Node<T> rp)
        {
            Node<T> p = new Node<T>(val, lp, rp);
            head = p;
        }
        public bool isEmpty()
        {
            if (head == null)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public Node<T> Root()
        {
            return head;
        }

        public Node<T> GetLChild(Node<T> p)
        {
            return p.LChild;
        }

        public Node<T> GetRChild(Node<T> p)
        {
            return p.RChild;
        }

        public void insertL(T val, Node<T> p)
        {
            Node<T> tmp = new Node<T>(val);
            tmp.LChild = p.LChild;
            p.LChild = tmp;
        }

        public void insertR(T val, Node<T> p)
        {
            Node<T> tmp = new Node<T>(val);
            tmp.RChild = p.RChild;
            p.RChild = tmp;
        }

        public Node<T> DeleteL(Node<T> p)
        {
            if ((p == null) || (p.LChild == null))
            {
                return null;
            }
            Node<T> tmp = p.LChild;
            p.LChild = null;
            return tmp;
        }

        public Node<T> DeleteR(Node<T> p)
        {
            if ((p == null) || (p.RChild == null))
            {
                return null;
            }
            Node<T> tmp = p.RChild;
            p.RChild = null;
            return tmp;
        }

        public Node<T> Seach(Node<T> root, T value) 
 
        {
            Node<T> p = root;
            if (p == null)
            {
                return null;
            }
            if (!p.Data.Equals(value))
            {
                return p;
            }
            if (p.LChild != null)
            {
                return Seach(p.LChild, value);
            }
            if (p.RChild != null)
            {
                return Seach(p.RChild, value);
            }
            return null;
        }

        public bool isLeaf(Node<T> p)
        {
            if (p != null && p.LChild == null && p.RChild == null)
            {
                return true;
            }
            else
            {
                return false;
            }
        }


        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            throw new NotImplementedException();
        }
    }

如果强制转换成T类型会提示
希望大神能够帮助我。新手的成长离不开大神的帮助 迭代器 泛型
[解决办法]
yield return用于IEnumerable而不是IEnumerator
[解决办法]
var list= preOrderTraverese(node.LChild);
foreach var t in list
 yield return t;

这个递归 preOrderTraverese(node.LChild);返回的实际是IEnumerator<T> 所以你想他东西添加进去请先用变量接收然后自己循环加入进去

ps：如果你看不清楚我的表达，那么请google“sp1234 重量级查询控件”这贴子
[解决办法]
本帖最后由 caozhy 于 2013-10-28 22:01:03 编辑 如果你非得返回一个IEnumerator，那么可以这样（C#不如VB，没法在匿名函数中使用yield）
        public IEnumerator GetEnumerator()
        {
            GetEnumerator1().GetEnumerator();
        }

        public IEnumerable<T> GetEnumerator1()
        {
            foreach (T item in preOrderTraverese(head)) yield return item;
            // or return preOrderTraverese(head);
        }

当然，preOrderTraverese也得按照类似的方式修改。

查看更多 下一篇