using System;

using System.Collections;

using System.Collections.Generic;

using System.Diagnostics;

using System.IO;

using System.Linq;

using System.Runtime.Serialization;

using System.Runtime.Serialization.Formatters.Binary;

using System.Threading;

using System.Threading.Tasks;

​

namespace App

{

​

    public static class External

    {

        static List<int> list = new List<int>();

​

        static public void Func(Action<List<int>> act)

        {

            foreach (var x in Enumerable.Range(0, 1000))

            {

                list.Clear();

                Enumerable.Range(x, 1000).ToList().ForEach(a => list.Add(a));

                act(list);

​

                list.Clear();

                Enumerable.Range(x, 1000).ToList().ForEach(a => list.Add(-a));

                act(list);

​

                // раскоментируй чтобы увидеть асинхронщину             

                //Thread.Sleep(3000);

            }

        }

    }

​

    class Program

    {

​

        static void Main(string[] args)

        {

            int total;

            Stopwatch t = new Stopwatch();

            Console.WriteLine("Wrapper1:");

            t.Start();

​

            total = new Wrapper1<List<int>>(External.Func).SelectMany(x => x).Sum();

​

            t.Stop();

            Console.WriteLine("Total: {0}, time: {1}", total, t.ElapsedMilliseconds);

​

​

            t.Reset();

            Console.WriteLine("Wrapper2:");

            t.Start();

​

            total = new Wrapper2<List<int>>(External.Func).SelectMany(x => x).Sum();

​

            t.Stop();

            Console.WriteLine("Total: {0}, time: {1}", total, t.ElapsedMilliseconds);

        }

    }

​

    public class Wrapper1<T> : IEnumerable<T>

    {

        List<T> list = new List<T>();

​

        public Wrapper1(Action<Action<T>> act) => act(x => list.Add(Clone(x)));

        public IEnumerator<T> GetEnumerator() => list.GetEnumerator();

        IEnumerator IEnumerable.GetEnumerator() => list.GetEnumerator();

​

        public static T Clone(T source)

        {

            if (!typeof(T).IsSerializable) throw new ArgumentException("The type must be serializable.", "source");

            if (Object.ReferenceEquals(source, null)) return default(T);

​

            IFormatter formatter = new BinaryFormatter();

            Stream stream = new MemoryStream();

            using (stream)

            {

                formatter.Serialize(stream, source);

                stream.Seek(0, SeekOrigin.Begin);

                return (T)formatter.Deserialize(stream);

            }

        }

    }

​

​

    class Wrapper2<T> : IEnumerable<T>

    {

        private readonly Action<Action<T>> _external;

​

        public Wrapper2(Action<Action<T>> externalFunc)

        {

            _external = externalFunc;

        }

​

        public IEnumerator<T> GetEnumerator()

        {

            return new List<T>().GetEnumerator();

        }

​

        IEnumerator IEnumerable.GetEnumerator()

        {

            return GetEnumerator();

        }

    }

​

}