È necessario il ciclo per copiare blocchi dall'array di byte

Question

Devo elaborare un grande array di byte che viene passato alla mia funzione. Ho bisogno di copiare il contenuto da questo array di byte in entrata in "pezzi" più piccoli a un array di byte in uscita.

Per ogni "blocco" di dati creato nell'array in uscita, devo chiamare un servizio web.

Al ritorno, ho bisogno di riprendere il ciclo attraverso l'array di byte in arrivo, continuando a passare un blocco intero o parziale di dati fino a quando l'array in arrivo completo viene elaborato (cioè inviato al servizio web in blocchi).

Sono molto nuovo a C# e sto lottando con un ciclo che funziona. So come chiamare il servizio web per gestire un "blocco", ma non riesco a ottenere il ciclo corretto. Ecco uno schizzo del pasticcio patetico che ho attualmente:

int chunkSize = 10000; 
byte[] outboundBuffer = new byte[chunkSize];  
while (BytesRead > 0) 
{ 
long i = 0; 
foreach (byte x in incomingArray) 
{ 
    BytesRead += 1; 
    outboundBuffer[i] = incomingArray[i] 
    i++; 
} 
uploadObject.Size = BytesRead; 
uploadObject.MTOMPayload = outboundBuffer; 

// call web service here and pass the uploadObject 

// get next "chunk" until incomingArray is fully processed 
} 

So che questo è un disastro e non funzionerà; qualcuno potrebbe abbozzare un loop appropriato per fare questo? Grazie mille.

Answer 1

Si potrebbe voler esaminare Array.Copy o Buffer.BlockCopy; questo pulirà le cose un po ', dal momento che non sarà necessario copiare tutti i byte singolarmente:

int incomingOffset = 0; 

while(incomingOffset < incomingArray.Length) 
{ 
    int length = 
     Math.Min(outboundBuffer.Length, incomingArray.Length - incomingOffset); 

    // Changed from Array.Copy as per Marc's suggestion 
    Buffer.BlockCopy(incomingArray, incomingOffset, 
        outboundBuffer, 0, 
        length); 

    incomingOffset += length; 

    // Transmit outbound buffer 
} 

Answer 2

ti sembra di aver suddiviso il vostro compito logicamente, dopo tutto, che hai descritto coerentemente con le parole . Ora fai solo il tuo codice.

Pseudo codice potrebbe essere qualcosa del tipo:

while (there are chunks in incoming array) 
    copy 1 chunk to outbound array 
    create uploadObject 
    call webservice 
endwhile 

Answer 3

Probabilmente si desidera Buffer.BlockCopy (la più cruda delle copie; idealmente adatto a byte[]).

Naturalmente, l'altra opzione è quella di utilizzare un MemoryStream al posto della matrice in uscita, e solo Write ad esso di volta in volta, quindi chiamare ToArray() o GetBuffer() sul MemoryStream (con GetBuffer(), è necessario guardare la lunghezza; con ToArray() è tagliato in modo automatico):

MemoryStream ms = new MemoryStream(); 
byte[] buffer = new byte[BUFFER_SIZE]; 
int bytesReceived; 
while((bytesReceived = GetNextChunk(buffer, 0, BUFFER_SIZE)) > 0) { 
    ms.Write(incomingArray, 0, bytesReceived); 
} 
byte[] final = ms.ToArray(); 

Answer 4

diffidare di chiamare servizi web in un ciclo in modo sincrono. Le chiamate sincrone al servizio web richiedono tempi indefiniti a causa della natura di HTTP e il ciclo potrebbe essere eseguito per un lungo periodo di tempo. È preferibile utilizzare un approccio asincrono.

Answer 5

Perché non utilizzare solo Array.Copy? http://msdn.microsoft.com/en-us/library/system.array.copy.aspx

es.

Array.Copy(srcBuffer, destBuffer, 1024);