Increment байт []

Question

У меня есть byte[] testKey = new byte[8];

Это, очевидно, начинается со всеми байтами как 0. Я хочу, чтобы пройти через все байты и приращения по 1 на каждой итерации цикла, так в конце концов, я прохожу все возможности массива байтов. Я также хочу сделать это как можно быстрее. Да, я пытаюсь написать грубый форкер.

Обновление У меня есть небезопасный метод работы, и он самый быстрый. Тем не менее, по моим расчетам, для каждого цикла с использованием .Net DESCryptoServiceProvider потребуется 76 000 000 лет, чтобы выполнить шифрование DES. 10 000 шифров занимают 1,3 секунды. Спасибо за все потрясающие ответы на самый бесполезный вопрос!

Answer 1

btw; это занимает много обработки, чтобы проверить 2^64 вариантов ...

Ну, быстрый способ может быть просто использовать Int64 (ака long) или UInt64 (ulong), а также использовать ++? Вам действительно нужен byte[]?

Как Hacky альтернативы, как насчет:

Array.Clear(data, 0, data.Length); 
while (true) 
{ 
    // use data here 
    if (++data[7] == 0) if (++data[6] == 0) 
    if (++data[5] == 0) if (++data[4] == 0) 
     if (++data[3] == 0) if (++data[2] == 0) 
     if (++data[1] == 0) if (++data[0] == 0) break; 
} 

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

unsafe static void Test() { 
    byte[] data = new byte[8]; 
    fixed (byte* first = data) { 
     ulong* value = (ulong*)first; 
     do { 
      // use data here 
      *value = *value + 1; 
     } while (*value != 0); 
    } 
} 

Answer 2

BitConverter.ToInt64/BitConverter.GetBytes - преобразующие 8 байт точно долго, и увеличивать его. Когда почти закончите преобразовать обратно в байты. Это самый быстрый способ в системе

Answer 3

for (UInt64 i = 0; i < UInt64.MaxValue; i++) 
{ 
    byte[] data = BitConverter.GetBytes(i) 
} 

Answer 4

байт [8] является по существу ULONG, но если вам действительно нужно, чтобы быть байт [8] вы можете использовать

byte[] bytes = new byte[8]; 
ulong i = 0; 
bytes = BitConverter.GetBytes(i); 

Answer 5

Это, как вы увеличиваете значение в массиве:

int index = testKey.Length - 1; 
while (index >= 0) { 
    if (testKey[index] < 255) { 
     testKey[index]++; 
     break; 
    } else { 
     testKey[index--] = 0; 
    } 
} 

Когда index будет -1 после этого кода, вы итерацию все комбинации.

Это будет немного быстрее, чем использование BitConverter, так как оно не создает новый массив для каждой итерации.

Edit:
Небольшой тест производительности показал, что это примерно 1400 раз быстрее, чем при использовании BitConverter ...

Answer 6

Какой большой вопрос! Вот способ сделать это без опасного кода:

public struct LongAndBytes 
{ 
    [FieldOffset(0)] 
    public ulong UlongValue; 
    [FieldOffset(0)] 
    public byte Byte0; 
    [FieldOffset(1)] 
    public byte Byte1; 
    [FieldOffset(2)] 
    public byte Byte2; 
    [FieldOffset(3)] 
    public byte Byte3; 
    [FieldOffset(4)] 
    public byte Byte4; 
    [FieldOffset(5)] 
    public byte Byte5; 
    [FieldOffset(6)] 
    public byte Byte6; 
    [FieldOffset(7)] 
    public byte Byte7; 

    public byte[] ToArray() 
    { 
     return new byte[8] {Byte0, Byte1, Byte2, Byte3, Byte4, Byte5, Byte6, Byte7}; 
    } 
} 


// ... 

    LongAndBytes lab = new LongAndBytes(); 

    lab.UlongValue = 0; 
    do { 
     // stuff 
     lab.UlongValue++; 
    } while (lab.ULongValue != 0); 

Каждый из членов Byte0 ... Byte7 перекрываться ULong и поделиться своим членам. Это не массив - я пробовал обдумывать это и имел неудовлетворительные результаты. Бьюсь об заклад, кто-то знает волшебную декларацию, чтобы это произошло. Я могу сделать это для P/Invoke, но не для использования в .NET, поскольку массив является объектом.

Answer 7

Вы можете извлечь байты с помощью битовых операторов:

byte[] bytes = new byte[8]; 
for (ulong u = 0; u < ulong.MaxValue; u++) 
{ 
    bytes[0] = (byte)(u & 0xff); 
    bytes[1] = (byte)((u >> 8) & 0xff); 
    bytes[2] = (byte)((u >> 16) & 0xff); 
    bytes[3] = (byte)((u >> 24) & 0xff); 
    bytes[4] = (byte)((u >> 32) & 0xff); 
    bytes[5] = (byte)((u >> 40) & 0xff); 
    bytes[6] = (byte)((u >> 48) & 0xff); 
    bytes[7] = (byte)((u >> 56) & 0xff); 
    // do your stuff... 
} 

Это меньше «хаком», так как он действует на беззнаковое 64-битное целое число, а затем извлечь байт. Однако будьте осторожны с CPU endianess.

Answer 8

byte[] array = new byte[8]; 
int[] shifts = new int[] { 0, 8, 16, 24, 32, 40, 48, 56 };  
for (long index = long.MinValue; index <= long.MaxValue; index++) 
{ 
    for (int i = 0; i < 8; i++) 
    { 
     array[i] = (byte)((index >> shifts[i]) & 0xff); 
    } 
    // test array 
} 

Answer 9

for (int i = 0; i < bytes.Length & 0 == ++bytes[i]; i++); 

Должно быть так же быстро, как небезопасный метод и позволяет массивы любого размера.