C # Problema utilizzando NET Blowfish: Come convertire da Uint32 [] per byte []

Question

In C #, sto usando il file BlowfishECB.cs Blowfish.NET 2.1.3 di ( può essere trovato qui )

In C ++, non si sa, ma è simile.

In C ++, la procedura di inizializzazione (blowfish) è il seguente:

void cBlowFish::Initialize(BYTE key[], int keybytes)

In C #, la procedura di inizializzazione (Blowfish) è lo stesso

public void Initialize(byte[] key, int ofs, int len) 

Questo è il problema:

Questo è come la chiave viene inizializzato in C ++

DWORD keyArray[2] = {0}; //declaration
...some code
blowfish.Initialize((LPBYTE)keyArray, 8);

Come si vede, la chiave è un array di due DWORDS, che è di 8 byte totale.

In C # dichiaro in quel modo, ma ottengo un errore

BlowfishECB blowfish = new BlowfishECB();
UInt32[] keyarray = new UInt32[2];
..some code
blowfish.Initialize(keyarray, 0, 8);

L'errore è:

Argomento '1': non può convertire da 'uint []' a 'byte []'

Che cosa sto facendo di sbagliato?

Grazie in anticipo!

Answer 1

È possibile utilizzare BitConverter per ottenere i byte da un UInt32.

---

Per fare questo, è necessario convertire ogni elemento in un ciclo. Vorrei fare qualcosa di simile:

private byte[] ConvertFromUInt32Array(UInt32[] array)
{
    List<byte> results = new List<byte>();
    foreach(UInt32 value in array)
    {
        byte[] converted = BitConverter.GetBytes(value);
        results.AddRange(converted);
    }
    return results.ToArray();
}

Per tornare:

private UInt32[] ConvertFromByteArray(byte[] array)
{
    List<UInt32> results = new List<UInt32>();
    for(int i=0;i<array.Length;i += 4)
    {
        byte[] temp = new byte[4];
        for (int j=0;j<4;++j)
            temp[j] = array[i+j];
        results.Add(BitConverter.ToUInt32(temp);
    }
    return results.ToArray();
}

Answer 2

Se si sta utilizzando VS2008 o C # 3.5, provare la seguente soluzione LINQ + BitConverter

var converted = 
  keyArray
    .Select(x => BitConverter.GetBytes(x))
    .SelectMany(x => x)
    .ToArray();

Rompere questo giù

• Il Select converte ogni UInt32 in un byte []. Il risultato è un oggetto IEnumerable
• Il SelectMany chiama flattes l'IEnumerable a IEnumerable
• ToArray () converte semplicemente il enumerable in un array

Modifica non LINQ soluzione che funziona altrettanto bene

List<byte> list = new List<byte>();
foreach ( UInt32 k in keyArray) {
  list.AddRange(BitConverter.GetBytes(k));
}
return list.ToArray();

Answer 3

Se avete bisogno di un modo più veloce per convertire i tipi di valore, è possibile utilizzare l'hack che ho descritto nel seguente risposta: Qual è il modo più veloce per convertire un float [] per un byte []

Questo mod evitare allocazioni di memoria e le iterazioni. Ti dà una visione diversa della matrice in O (1).

Ovviamente si deve utilizzare solo questo se la prestazione è un problema (evitare l'ottimizzazione prematura).