Need-Schleife zum Kopieren von Chunks aus Byte-Array

Question

Ich muss ein großes Byte-Array verarbeiten, die an meine Funktion übergeben wird. Ich muss den Inhalt von diesem ankommenden Byte-Array in kleineren "Chunks" in ein ausgehenden Byte-Array kopieren.

Für jeden "Chunk" von Daten im Outbound-Array erstellt, muss ich einen Web-Service aufrufen.

Nach der Rückkehr muss ich wieder durch die eingehenden Byte-Array durchlaufen, weiterhin eine ganze oder teilweise Datenblock übergeben, bis die komplette eingehende Array verarbeitet wird (d. H. An den Web-Service in Chunks gesendet).

Ich bin sehr neu in C# und ich kämpfe mit einer Schleife, die funktioniert. Ich weiß, wie man den Webservice anruft, um einen "Brocken" zu behandeln, aber ich kann die Schleife nicht richtig machen. Hier ist eine Skizze der pathetischen Sauerei, die ich derzeit habe:

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 
} 

Ich weiß, das ist ein Durcheinander und wird nicht funktionieren; Könnte jemand eine richtige Schleife skizzieren, um das zu erreichen? Vielen Dank.

Answer 1

Sie könnten in Array.Copy oder Buffer.BlockCopy suchen; dies wird die Dinge sauber ein wenig, da man nicht einzeln alle Bytes zu kopieren haben:

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

Sie scheinen Ihre Aufgabe logisch zusammengebrochen, schließlich haben Sie beschrieben es kohärent mit Worten . Jetzt machen Sie Ihren Code einfach.

könnte Pseudo-Code so etwas wie:

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

Answer 3

Sie wahrscheinlich Buffer.BlockCopy wollen (die rawest der Kopien, ideal geeignet für byte[]).

Natürlich ist die andere Option ein MemoryStream anstelle der Outbound-Array zu verwenden, und nur Write, um es jedes Mal, rufen Sie dann ToArray() oder GetBuffer() auf dem MemoryStream (mit GetBuffer(), müssen Sie die Länge sehen, mit ToArray() es wird automatisch für Sie) getrimmt:

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

Seien Sie vorsichtig Web-Dienste Aufruf synchron in einer Schleife. Synchrone Web-Service-Aufrufe dauern aufgrund der Art von HTTP unbestimmte Zeit und Ihre Schleife kann für eine lange Zeit ausgeführt werden. Es ist vorzuziehen, einen asynchronen Ansatz zu verwenden.

Answer 5

Warum nicht einfach Array.Copy verwenden? http://msdn.microsoft.com/en-us/library/system.array.copy.aspx

z.

Array.Copy(srcBuffer, destBuffer, 1024);