using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.Runtime.InteropServices;

​

namespace UnsafeList

{

    public class Poco

    {

        public int Field1;

        public int Field2;

        public int Field3;

        public int Field4;

        public int Field5;

        public int Field6;

        public int Field7;

        public int Field8;

        public int Field9;

        public int Field10;

        public int Field11;

        public int Field12;

        public int Field13;

        public int Field14;

        public int Field15;

        public int Field16;

    }

​

    public class Program

    {

        public static Poco CreatePoco(int i)

        {

            return new Poco

            {

                Field1 = i,

                Field2 = i - 1,

                Field3 = i - 2,

                Field4 = i - 3,

                Field5 = i - 4,

                Field6 = i - 5,

                Field7 = i - 6,

                Field8 = i - 7,

                Field9 = i - 7,

                Field10 = i - 6,

                Field11 = i - 5,

                Field12 = i - 4,

                Field13 = i - 3,

                Field14 = i - 2,

                Field15 = i - 1,

                Field16 = i

            };

        }

​

        static void TestArray(int elementsCount)

        {

            Console.WriteLine("Array");

            var stopwatch = new Stopwatch();

            stopwatch.Start();

            var array = new Poco[elementsCount];

​

            for (int i = 0; i < elementsCount; ++i)

            {

                var poco = CreatePoco(i);

                array[i] = poco;

            }

​

            stopwatch.Stop();

            Console.WriteLine("Insertion time: " + stopwatch.ElapsedMilliseconds);

            int sum = 0;

​

            stopwatch.Restart();

​

            for (int i = 0; i < elementsCount; ++i)

            {

                var poco = array[i];

                sum += poco.Field1;

                sum += poco.Field2;

                sum += poco.Field3;

                sum += poco.Field4;

                sum += poco.Field5;

                sum += poco.Field6;

                sum += poco.Field7;

                sum += poco.Field8;

                sum += poco.Field9;

                sum += poco.Field10;

                sum += poco.Field11;

                sum += poco.Field12;

                sum += poco.Field13;

                sum += poco.Field14;

                sum += poco.Field15;

                sum += poco.Field16;

            }

​

            stopwatch.Stop();

​

            Console.WriteLine("Sum: " + sum);

            Console.WriteLine("Calculation time: " + stopwatch.ElapsedMilliseconds);

        }

​

        static void TestList(int elementsCount)

        {

            Console.WriteLine("List");

            var stopwatch = new Stopwatch();

            stopwatch.Start();

​

            var normalList = new List<Poco>(elementsCount);

​

            for (int i = 0; i < elementsCount; ++i)

            {

                var poco = CreatePoco(i);

                normalList.Add(poco);

            }

            stopwatch.Stop();

            Console.WriteLine("Insertion time: " + stopwatch.ElapsedMilliseconds);

            int sum = 0;

​

            stopwatch.Restart();

​

            for (int i = 0; i < elementsCount; ++i)

            {

                var poco = normalList[i];

                sum += poco.Field1;

                sum += poco.Field2;

                sum += poco.Field3;

                sum += poco.Field4;

                sum += poco.Field5;

                sum += poco.Field6;

                sum += poco.Field7;

                sum += poco.Field8;

                sum += poco.Field9;

                sum += poco.Field10;

                sum += poco.Field11;

                sum += poco.Field12;

                sum += poco.Field13;

                sum += poco.Field14;

                sum += poco.Field15;

                sum += poco.Field16;

            }

​

            stopwatch.Stop();

​

            Console.WriteLine("Sum: " + sum);

            Console.WriteLine("Calculation time: " + stopwatch.ElapsedMilliseconds);

        }

​

        static void TestSafeList(int elementsCount)

        {

            Console.WriteLine("SafeList");

            var stopwatch = new Stopwatch();

            stopwatch.Start();

​

            var safeList = new SafeList<Poco>(elementsCount, 18);

            for (int i = 0; i < elementsCount; ++i)

            {

                var poco = CreatePoco(i);

                safeList.Add(poco);

            }

​

            stopwatch.Stop();

            Console.WriteLine("Insertion time: " + stopwatch.ElapsedMilliseconds);

            int sum = 0;

​

            stopwatch.Restart();

​

            for (int i = 0; i < elementsCount; ++i)

            {

                var poco = safeList.Get(i);

                sum += poco.Field1;

                sum += poco.Field2;

                sum += poco.Field3;

                sum += poco.Field4;

                sum += poco.Field5;

                sum += poco.Field6;

                sum += poco.Field7;

                sum += poco.Field8;

                sum += poco.Field9;

                sum += poco.Field10;

                sum += poco.Field11;

                sum += poco.Field12;

                sum += poco.Field13;

                sum += poco.Field14;

                sum += poco.Field15;

                sum += poco.Field16;

            }

​

            stopwatch.Stop();

​

            Console.WriteLine("Sum: " + sum);

            Console.WriteLine("Calculation time: " + stopwatch.ElapsedMilliseconds);

​

            safeList.Free();

        }

​

        public static void Main()

        {   

            var testsCount = 3;

            var elementsCount = 100 * 1000;

​

            Console.WriteLine("------------------------");

            for (int i = 0; i < testsCount; ++i)

            {

                TestArray(elementsCount);

            }

​

            GC.Collect();

            GC.WaitForPendingFinalizers();

​

​

​

            Console.WriteLine("------------------------");

            for (int i = 0; i < testsCount; ++i)

            {

                TestList(elementsCount);

            }

​

            GC.Collect();

            GC.WaitForPendingFinalizers();

​

​

​

            Console.WriteLine("------------------------");

            for (int i = 0; i < testsCount; ++i)

            {

                TestSafeList(elementsCount);

            }

        }

    }

}

​

namespace UnsafeList

{

    public class SafeList<T> where T : class

    {

        private readonly int _elementSize;

        private T _target;

        private int[] _storage;

        private int _currentIndex = -1;

        private Holder<T> holder = new Holder<T>();

        GCHandle storageHandle;

        GCHandle holderHandle;

​

        public SafeList(int size, int elementSize)

        {

            _elementSize = elementSize;

            _storage = new int[size * _elementSize];

            _target = default(T);

            storageHandle = GCHandle.Alloc(_storage);

            holderHandle = GCHandle.Alloc(holder);

        }

​

        public int Add(T item)

        {

            _currentIndex++;

​

            GCHandle handle = GCHandle.Alloc(item);

            var itemAddress = Marshal.ReadIntPtr(GCHandle.ToIntPtr(handle)) - 4; // Assumes 86

            handle.Free();

​

            for (int i = 1; i < _elementSize; ++i)

            {

                _storage[_currentIndex*_elementSize + i] = Marshal.ReadInt32(itemAddress + i * 4);

            }

​

​

            return _currentIndex;

        }

​

        public T GetInternal(int index)

        {

            var storageAddress = Marshal.ReadIntPtr(GCHandle.ToIntPtr(storageHandle));

            var holderAddress = Marshal.ReadIntPtr(GCHandle.ToIntPtr(holderHandle));

​

            Marshal.WriteIntPtr(holderAddress, 4, storageAddress + 2 * 4 + index * _elementSize * 4 + 4); // Skip 2*4 for Method Handle and array size, index * _elementSize * 4 for elements, 4 for sync block

​

            return holder.reference;

        }

​

        public T Get(int index)

        {

            return GetInternal(index);

        }

​

        public void Free()

        {

            storageHandle.Free();

            holderHandle.Free();

        }

    }

​

    class Holder<T>

    {

        public T reference;

    }

}