Константы в Objective-C

Для примитивных типов (включая байты) используйте System.Buffer.BlockCopy вместо System.Array.Copy. Это быстрее.

Я назначил каждый из предложенных методов в цикле, выполненном 1 миллион раз, используя 3 массива по 10 байт каждый. Вот результаты:

1. Новый байт-массив с использованием System.Array.Copy - 0.2187556 секунд
2. Новый байт-массив с использованием System.Buffer.BlockCopy - 0.1406286 секунд
3. IEnumerable & lt ; byte> с использованием оператора C # yield - 0.0781270 секунд
4. IEnumerable & lt; byte> с использованием Concact & lt;> - 0.0781270 секунд LINQ

Я увеличил размер каждого массива до 100 элементов и повторно запустить тест:

1. Новый массив байтов с использованием System.Array.Copy - 0.2812554 секунд
2. Новый байт-массив с использованием System.Buffer.BlockCopy - 0.2500048 секунд
3. IEnumerable & lt; byte> с использованием оператора C # yield - 0.0625012 секунд
4. IEnumerable & lt; byte> с использованием Concact & lt;> - 0.0781265 секунд LINQ

Я увеличил размер каждого массива до 1000 элементов и повторного запуска теста:

1. Новый массив байтов с использованием System.Array.Copy - 1.0781457 секунд
2. Новый массив байтов с использованием System.Buffer.BlockCopy - 1.0156445 секунд
3. IEnumerable & lt; byte> с использованием оператора C # yield - 0.0625012 секунд
4. IEnumerable & lt; byte> с использованием Concact & lt;> - 0.07812 LINQ 65 секунд

Наконец, я увеличил размер каждого массива до 1 миллиона элементов и перезапустил тест, выполнив каждый цикл только 4000 раз:

1. Новый байт-массив с использованием System.Array.Copy - 13.4533833 секунд
2. Новый массив байтов с использованием System.Buffer.BlockCopy - 13.1096267 секунд
3. IEnumerable & lt; byte> с использованием оператора C # yield - 0 секунд
4. IEnumerable & lt; byte> используя Concact & lt;> - 0 секунд LINQ

Итак, если вам нужен новый массив байтов, используйте

byte[] rv = new byte[a1.Length + a2.Length + a3.Length];
System.Buffer.BlockCopy(a1, 0, rv, 0, a1.Length);
System.Buffer.BlockCopy(a2, 0, rv, a1.Length, a2.Length);
System.Buffer.BlockCopy(a3, 0, rv, a1.Length + a2.Length, a3.Length);

Но, если вы может использовать IEnumerable<byte>, DEFINITELY предпочитает метод Concat & lt;> LINQ. Это немного медленнее, чем оператор C # yield, но является более кратким и более элегантным.

IEnumerable<byte> rv = a1.Concat(a2).Concat(a3);

Если у вас есть произвольное количество массивов и вы используете .NET 3.5, вы можете сделать System.Buffer.BlockCopy Решение более общее:

private byte[] Combine(params byte[][] arrays)
{
    byte[] rv = new byte[arrays.Sum(a => a.Length)];
    int offset = 0;
    foreach (byte[] array in arrays) {
        System.Buffer.BlockCopy(array, 0, rv, offset, array.Length);
        offset += array.Length;
    }
    return rv;
}

* Примечание. В приведенном выше блоке вы должны добавить следующее пространство имен вверху, чтобы оно работало.

using System.Linq;

К Jon Skeet's (байтовый массив против IEnumerable & lt; byte>), я повторно запустил последний тест времени (1 миллион элементов, 4000 итераций), добавив цикл, который выполняет итерацию по всему массиву с каждым проходом:

1. Массив нового байта с использованием System.Array.Copy - 78.20550510 секунд
2. Новый байт-массив с использованием System.Buffer.BlockCopy - 77.89261900 секунд
3. IEnumerable & lt; byte> с использованием C # yield оператор - 551.7150161 секунд
4. IEnumerable & lt; byte> с использованием Concact & lt;> - 448.1804799 секунд LINQ

Суть в том, что ОЧЕНЬ важно, чтобы понять эффективность как креацио n и использование результирующей структуры данных. Простое сосредоточение на эффективности создания может не учитывать неэффективность, связанную с использованием. Кудос, Джон.