关于Duck Typing的性能分析 Draft

using System;
using System.Threading;
using System.Collections.Generic;
using System.Diagnostics;

namespace DuckTyping
{

    class Program
    {
        public static int Range = 10000000;

        static void Main(string[] args)
        {
            string newRange = Console.ReadLine();
            if (!string.IsNullOrEmpty(newRange))
            {
                Range = Int32.Parse(newRange);
            }

            FakeEnumerable fake = new FakeEnumerable();
            RealEnumerable real = new RealEnumerable();
            YieldEnumerable yield = new YieldEnumerable();

            Stopwatch sw = new Stopwatch();
            sw.Start();

            foreach (var item in fake)
            {
            }

            sw.Stop();
            Console.WriteLine("Duck Typing : {0}",sw.ElapsedMilliseconds);
            sw.Reset();
            sw.Start();

            foreach (var item in real)
            {
            }

            sw.Stop();
            Console.WriteLine("Interface compl: {0}", sw.ElapsedMilliseconds); sw.Reset();
            sw.Reset();
            sw.Start();

            foreach (var item in yield)
            {
            }

            sw.Stop();
            Console.WriteLine("Yield compl: {0}", sw.ElapsedMilliseconds);


            Console.ReadKey();
        }
    }

    public class FakeEnumerable
    {
        public FakeEnumerator GetEnumerator()
        {
            return new FakeEnumerator();
        }
    }

    public class FakeEnumerator
    {
        public FakeEnumerator()
        {
            this.Current = 1;
        }

        public int Current {get;set;}

        public bool MoveNext()
        {
            Current++;
            return Current < Program.Range;
        }
    }

    public class RealEnumerable : IEnumerable<int>
    {
        public IEnumerator<int> GetEnumerator()
        {
            return new RealEnumerator();
        }

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

    public class RealEnumerator : IEnumerator<int>
    {
        private int current;

        public RealEnumerator()
        {
            this.current = 0;
        }

        public int Current
        {
            get { return this.current; }
        }

        public void Dispose()
        {
        }

        object System.Collections.IEnumerator.Current
        {
            get { return this.current; }
        }

        public bool MoveNext()
        {
            current++;
            return current < Program.Range;
        }

        public void Reset()
        {
            throw new NotImplementedException();
        }
    }

    public class YieldEnumerable : IEnumerable<int>
    {
        private static int index = 0;

        public IEnumerator<int> GetEnumerator()
        {
            while (index < Program.Range)
                yield return index++;
        }

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