Самый эффективный способ добавления массивов в C #?

Question

Я вытаскиваю данные из старой школы ActiveX в виде массивов двойников. Изначально я не знаю окончательного количества образцов, которые я на самом деле получу.

Каков наиболее эффективный способ объединения этих массивов в C #, когда я вытаскиваю их из системы?

Answer 1

Вы не можете добавить к фактическому массиву - размер массива фиксирован во время создания. Вместо этого используйте List<T>, который может расти по мере необходимости.

Либо сохраняйте список массивов и объединяйте их все, только когда вы все захватили.

См. сообщение Эрика Липперта в блоге о массивах , чтобы получить более подробную информацию и понимание, чем я мог бы реально представить:)

Answer 2

Я полагаю, если у вас есть 2 массива одного типа, которые вы хотите объединить в третий массив, есть очень простой способ сделать это.

вот код:

String[] theHTMLFiles = Directory.GetFiles(basePath, "*.html");
String[] thexmlFiles = Directory.GetFiles(basePath, "*.xml");
List<String> finalList = new List<String>(theHTMLFiles.Concat<string>(thexmlFiles));
String[] finalArray = finalList.ToArray();

Answer 3

Рекомендую ответ, найденный здесь: Как объединить два массива в C #?

, например

var z = new int[x.Length + y.Length];
x.CopyTo(z, 0);
y.CopyTo(z, x.Length);

Answer 4

Конкатенация массивов проста с использованием расширений linq, которые входят в стандартную комплектацию .Net 4

Самое важное, что нужно помнить, это то, что linq работает с IEnumerable<T> объектами, поэтому для получения массива в качестве результата вы должны использовать метод .ToArray() в конце

Пример объединения двух байтовых массивов:

byte[] firstArray = {2,45,79,33};
byte[] secondArray = {55,4,7,81};
byte[] result = firstArray.Concat(secondArray).ToArray();

Answer 5

Решение выглядит очень увлекательно, но объединить массивы можно всего за два утверждения. Когда вы обрабатываете большие байтовые массивы, я полагаю, что неэффективно использовать связанный список для хранения каждого байта.

Вот пример кода для чтения байтов из потока и расширения массива байтов на лету:

    byte[] buf = new byte[8192];
    byte[] result = new byte[0];
    int count = 0;
    do
    {
        count = resStream.Read(buf, 0, buf.Length);
        if (count != 0)
        {
            Array.Resize(ref result, result.Length + count);
            Array.Copy(buf, 0, result, result.Length - count, count);
        }
    }
    while (count > 0); // any more data to read?
    resStream.Close();

Answer 6

с помощью этого мы можем добавить два массива без цикла.

Я полагаю, если у вас есть 2 массива одного типа, которые вы хотите объединить в один из массивов, есть очень простой способ сделать это.

Вот код:

String[] TextFils = Directory.GetFiles(basePath, "*.txt");
String[] ExcelFils = Directory.GetFiles(basePath, "*.xls");
String[] finalArray = TextFils.Concat(ExcelFils).ToArray();

или

String[] Fils = Directory.GetFiles(basePath, "*.txt");
String[] ExcelFils = Directory.GetFiles(basePath, "*.xls");
Fils = Fils.Concat(ExcelFils).ToArray();

Answer 7

Возможно, вам не нужно объединять конечный результат в непрерывный массив. Вместо этого продолжайте добавлять к списку, как предложено Джоном. В итоге у вас будет массив с зубчатыми краями (ну, фактически, почти прямоугольный) Когда вам нужно получить доступ к элементу по индексу, используйте следующую схему индексации:

double x = list[i / sampleSize][i % sampleSize];

Итерация по зубчатому массиву также проста:

for (int iRow = 0; iRow < list.Length; ++iRow) {
  double[] row = list[iRow];
  for (int iCol = 0; iCol < row.Length; ++iCol) {
    double x = row[iCol];
  }
}

Это экономит ваше выделение памяти и копирование за счет немного более медленного доступа к элементу. Будет ли это чистый выигрыш в производительности, зависит от размера ваших данных, схем доступа к данным и ограничений памяти.

Answer 8

Если вы можете сделать приблизительное число элементов, которые будут там в конце, используйте перегрузку конструктора List, который принимает значение в качестве параметра. Вы сохраните несколько дорогих списков дубликатов. В противном случае вы должны заплатить за это.

Answer 9

Вот полезный класс, основанный на том, что сказал Константин:

class Program
{
    static void Main(string[] args)
    {
        FastConcat<int> i = new FastConcat<int>();
        i.Add(new int[] { 0, 1, 2, 3, 4 });
        Console.WriteLine(i[0]);
        i.Add(new int[] { 5, 6, 7, 8, 9 });
        Console.WriteLine(i[4]);

        Console.WriteLine("Enumerator:");
        foreach (int val in i)
            Console.WriteLine(val);

        Console.ReadLine();
    }
}

class FastConcat<T> : IEnumerable<T>
{
    LinkedList<T[]> _items = new LinkedList<T[]>();
    int _count;

    public int Count
    {
        get
        {
            return _count;
        }
    }

    public void Add(T[] items)
    {
        if (items == null)
            return;
        if (items.Length == 0)
            return;

        _items.AddLast(items);
        _count += items.Length;
    }

    private T[] GetItemIndex(int realIndex, out int offset)
    {
        offset = 0; // Offset that needs to be applied to realIndex.
        int currentStart = 0; // Current index start.

        foreach (T[] items in _items)
        {
            currentStart += items.Length;
            if (currentStart > realIndex)
                return items;
            offset = currentStart;
        }
        return null;
    }

    public T this[int index]
    {
        get
        {
            int offset;
            T[] i = GetItemIndex(index, out offset);
            return i[index - offset];
        }
        set
        {
            int offset;
            T[] i = GetItemIndex(index, out offset);
            i[index - offset] = value;
        }
    }

    #region IEnumerable<T> Members

    public IEnumerator<T> GetEnumerator()
    {
        foreach (T[] items in _items)
            foreach (T item in items)
                yield return item;
    }

    #endregion

    #region IEnumerable Members

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    #endregion
}

Answer 10

Предложение Олмо очень хорошее, но я бы добавил это: Если вы не уверены в размере, лучше сделать его немного больше, чем немного меньше. Когда список заполнен, имейте в виду, что он удвоит свой размер, чтобы добавить больше элементов.

Например: предположим, вам понадобится около 50 элементов. Если вы используете размер 50 элементов, а конечное число элементов - 51, вы получите список размером 100 с 49 потерянными позициями.