Нужна оптимизация

[WorldMaster]

Здравствуйте, есть необходимость разработать аналитическую систему которая работает с большим количеством данных.
Большая часть системы разработана и теперь встает вопрос оптимизации скорости.
И вот что получается:
Стандартный контейнер List<> не устраивает потому что метод ToArray работает очень долго. Написал свой контейнер упрощенный - получил другую проблему. Заполнение контейнера очень долгое.

Подскажите пожалуйста как сделать свой класс-контейнер чтобы добиться максимум производительности?

Мой класс:

public class PriceCollection
    {

        double[] _list;

        public PriceCollection()
        {
            _list = new double[0];
        }

        /// <summary>
        /// Добавляет переменную в конец списка
        /// </summary>
        /// <param name="value"></param>
        public void Add(double value)
        {
            if (_list.Length == 0)
            {
                _list = new double[1] { value };
                return;
            }

            double[] tmp = new double[_list.Length + 1];
            Array.Copy(_list, tmp, _list.Length);
            tmp[_list.Length] = value;
            _list = tmp;
        }

        /// <summary>
        /// Удаляет переменную по указанному индексу
        /// </summary>
        /// <param name="Index"></param>
        public void Remove(int Index)
        {
        }

        /// <summary>
        /// Получает список всех переменных
        /// </summary>
        /// <returns></returns>
        public double[] ToArray()
        {
            return _list;
        }
    }

Результаты тестирования в прикрепленном изображении.
Хочется чтобы коллекция обладала скоростью добавления как у List а выборкой массива как у меня

[_-Re@l-_]

Как по-моему, производительность вашего Add упирается в Array.Copy - нехорошо. Попробуйте копировать вручную, а не существующими методами.
P.S. Могу ошибаться - пробуйте.

[WorldMaster]

Сообщение от _-Re@l-_

Как по-моему, производительность вашего Add упирается в Array.Copy - нехорошо. Попробуйте копировать вручную, а не существующими методами.
P.S. Могу ошибаться - пробуйте.

Все перепробовал .. и Marshal и for() - Array.Copy это самое быстрое

[Luuzuk]

Array.Copy это самое быстрое

А с Buffer.BlockCopy не сравнивали?


-----------

Еще как вариант - не увеличивать количество элементов массива каждый раз при добавлении, а удваивать размер массива при недостатке места. Такая идея заложена, например, в StringBuilder

    public class ArrayableCollection<T>
    {
        // массив данных
        private T[] _data;
        // длина массива
        private Int32 _length;
        // количество элементов в массиве (меньше либо равно длине)
        private Int32 _count;

        /// <summary>
        /// Конструктор
        /// </summary>
        /// <param name="initialLength">Начальное кол-во элементов в массиве</param>
        public ArrayableCollection(int initialLength)
        {
            if (initialLength <=0)
                 throw new Exception("Длина массива должна быть больше нуля!");
            _length = initialLength;
            _data = new T[initialLength];
            _count = 0;
        }

        /// <summary>
        /// Добавляет значение в массив
        /// </summary>
        /// <param name="value">значение</param>
        public void Add(T value)
        {
            // Если элемент не помещается в массив - увеличиваем массив в 2 раза
            if (_count >= (_length - 1))
            {
                if (_length == Int32.MaxValue)
                    throw new Exception("Массив слишком велик :(");

                Int32 newLength;
                if (_length >= Int32.MaxValue / 2)
                    newLength = Int32.MaxValue;
                else newLength = _length * 2;

                T[] newData = new T[newLength];
                Buffer.BlockCopy(_data, 0, newData, 0, _count);
                _data = newData;
                _length = newLength;
            }
            _data[_count++] = value;
        }

        public T[] ToArray()
        {
            return _data;
        }
    }

P.S. класс ниразу не потокобезопасен) впрочем как и ваш

[WorldMaster]

Вот результат с вашим примером ....
Как то странно время показывается ... Если первый проход то время побольше ... второй проход поменьше ...
ну в целом вот такой вот результат получился:

Потокобезопасность не очень нужна поскольку к данному массиву не будет доступа из других потоков.

Все равно штатный выигрывает почему то ..

[Luuzuk]

Как то странно время показывается

http://habrahabr.ru/post/191636/

[WorldMaster]

Сообщение от Luuzuk

http://habrahabr.ru/post/191636/

И еще особенность .. на выходе ToArray() мне нужен массив не содержащий пустых значений. А ваш класс вернет мне несколько пустых значений в конце ... Как с этим бороться?

[Luuzuk]

Вернуть новый массив, обрезанный по значению поля _count с помощью того же самого Buffer.BlockCopy. И окончательно добить этим производительность

[WorldMaster]

Сообщение от Luuzuk

Вернуть новый массив, обрезанный по значению поля _count с помощью того же самого Buffer.BlockCopy. И окончательно добить этим производительность

Так выход то есть какой нибудь?? Причем проблема то в методе ToArray(). В целом класс List очень устраивает ... но я как глянул на задержки ...

Неужели нету способа максимально быстро скопировать данные?
Пусть даже из List но в массив.

[Luuzuk]

Чем массив отличается от списка? Тем, что массив занимает один большой непрерывный кусок в памяти (список может быть разбросан по оперативке как угодно). Этим и объясняются сложности в переходе от списка к массиву. Отсюда и задержки. Если для вас это настолько критично - напишите хранилище этих данных на с/с++ и работайте с неуправляемым кодом