yield实现迭代以及APM

　　yield关键字用于迭代器块中用于枚举数提供值或发出一个迭代结束标识，它只能出现在iterator块中。

先看看一个传统迭代器的编写：

        public class Node
        {
            public object data;
            public Node next;

            public override string ToString()
            {
                return data.ToString();
            }
        }

自定义一个集合并可枚举：

public class NodeCollection : IEnumerable<Node>
        {

            private Node[] nodes;
            private int index;
            private int capacity;

            public NodeCollection(int capacity)
            {
                nodes = new Node[capacity];
                index = 0;
                this.capacity = capacity;
            }

            public Node this[int _index]
            {
                get
                {
                    return nodes[_index];
                }
                
            }

            public void Add(Node node)
            {
                if (index > capacity - 1)
                {
                    throw new ArgumentException("run out of capacity");
                }
                nodes[index++] = node;
            }

            #region IEnumerable<Node> Members

            public IEnumerator<Node> GetEnumerator()
            {
                return new NodeEnumerator(nodes);
            }

            #endregion

        }

该集合是的迭代器是用传统方法来实现的，需要实现：IEnumerator<>

public class NodeEnumerator : IEnumerator<Node>
        {
            public Node[] nodes;
            int index;

            public NodeEnumerator(Node[] _nodes)
            {
                this.nodes = new Node[_nodes.Length];
                _nodes.CopyTo(nodes, 0);
                index = -1;
            }

            #region IEnumerator<Node> Members

            public Node Current
            {
                get 
                {
                    return nodes[index];
                }
            }

            #endregion

            #region IDisposable Members

            public void Dispose()
            {
                nodes = null;
            }

            #endregion

            #region IEnumerator Members

            object System.Collections.IEnumerator.Current
            {
                get { return nodes[index]; }
            }

            public bool MoveNext()
            {
                index++;
                if (index < nodes.Length)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }

            public void Reset()
            {
                index = -1;
            }

            #endregion
        }

看得出来很繁锁，这在.net 1.1框架的做法，1.1之后不需要这么做，直接用yield关键字搞定一切，看代码：

           public IEnumerator<Node> GetEnumerator()
            {
                //return new NodeEnumerator(nodes);
                 for (int i = 0; i < capacity; i++)
                {
                    yield return nodes[i];
                }
            }

非常简单，这完全符合MS的原则：Write less code,Do more things

再看看得用这yield关键字改变传统的APM编程模型，通常利用传统异步编程模型的都是一个BeginXXX(AsyncCallback)的时候,然后EndXXX(IAsyncResult)，程序写起来流畅，因为老是要写callback函数，要做的的事其实要让BeginXXX完成后,直接yield return number 返回一个得用枚举器中断当前线程，当BeginXXX()操作完成后，只需要在它的回调函数完成一次MoveNext（）操作再执行yield return number之后的代码，这时候其实现就调用 EndXXX来完成本次异步调用，看代码

static void Main()
        {
            DownloadContext context = new DownloadContext();
            AsyncDownload download = new AsyncDownload();
            context.Start(download.Download(context));

            Console.Read();
        }

        public IEnumerator<int> Download(DownloadContext context)
        {
            var request = HttpWebRequest.Create("http://www.baidu.com");
            var ar = request.BeginGetResponse(context.Continue(), null);
            yield return 1;
            var response = request.EndGetResponse(ar);

            byte[] buffer = new byte[1024];
            using (Stream sr = response.GetResponseStream())
            using(StreamReader sr = new StreamReader(response.GetResponseStream()))
            {
                //Console.WriteLine(sr.ReadToEnd());
                var ar2 = sr.BeginRead(buffer, 0, buffer.Length, context.Continue(), null);
                //Console.WriteLine(BitConverter.ToString(buffer));
                yield return 1;
                sr.EndRead(ar2);
            }
        }
    }

    public class DownloadContext
    {
        private IEnumerator<int> enumerator;

        public AsyncCallback Continue()
        {
            return (ar) => enumerator.MoveNext();
        }

        public void Start(IEnumerator<int> enumerator)
        {
            this.enumerator = enumerator;
            enumerator.MoveNext();
        }
    }

这里有更详细的介绍关于APM编程的:http://www.cnblogs.com/yuyijq/archive/2011/02/24/1963326.html

我借鉴了作者的思路 ，自己再理一下，其实都是些老掉牙的技术了，手痒的时候再写一遍未尝不是一件好事！