Brauchen Schleife zum kopieren von Blöcken aus byte-array

Habe ich zum verarbeiten einer großen byte-array übergeben wird, meine Funktion. Brauche ich zum kopieren der Inhalte aus dieser eingehenden byte-array in kleineren "Brocken", um ein outbound-byte-array.

Für jeden "chunk" von Daten erstellt, die in der outbound-array, muss ich für den Aufruf eines web service.

Nach der Rückkehr, ich braucht, um wieder die Schleife durch die eingehende byte-array, weiter pass, eine ganze oder teilweise Brocken von Daten, bis die kompletten incoming-array verarbeitet werden (d.h. die an den Webdienst gesendet in Blöcken).

Ich bin sehr neu in C# und ich kämpfen mit einer Schleife, die funktioniert. Ich weiß, wie Sie zum aufrufen der web-Dienst zu verarbeiten, einen "chunk" aber ich kann nicht die Schleife korrekt. Hier ist eine Skizze von der erbärmlichen Schlamassel 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 eine Sauerei und funktioniert nicht; kann mir da jemand Skizze einer richtigen Schleife, um dies getan? Dank sehr viel.

InformationsquelleAutor John Adams | 2009-02-24

bytearray c#

Vielleicht möchten Sie sich in Array.Kopieren oder Puffer.BlockCopy; dies wird reinigen Sie die Dinge ein wenig, da Sie nicht haben, um kopieren Sie alle bytes einzeln:

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
 }

Dieser code war sehr schön für mich. Ich danke Ihnen SO sehr für Ihre Hilfe.

InformationsquelleAutor Daniel LeCheminant

4

Möchten Sie wahrscheinlich Buffer.BlockCopy (die rohsten der Kopien; ideal geeignet für byte[]).

Natürlich die andere Möglichkeit ist die Verwendung eines MemoryStream an die Stelle der outbound-array, und nur Write zu jeder Zeit, dann rufen ToArray() oder GetBuffer() auf die MemoryStream (mit GetBuffer() Sie brauchen, um zu sehen die Länge; mit ToArray() es beschnitten ist, automatisch für Sie):
```
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();
```
InformationsquelleAutor Marc Gravell
3

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

zB.
```
Array.Copy(srcBuffer, destBuffer, 1024);
```
InformationsquelleAutor Gautam
0

Vorsichtig sein, aufrufen von web-services in einer Schleife synchron. Synchrone web-service-Aufrufe, dauert unbestimmte Zeit, aufgrund der Natur von HTTP und deine Schleife könnte für eine lange Zeit laufen. Es ist vorzuziehen, einen asynchronen Ansatz.

InformationsquelleAutor Chetan Sastry
-2

Scheinen Sie aufgebrochen, Ihre Aufgabe logisch, denn Sie haben ja zusammenhängend beschrieben es mit Worten. Jetzt gerade machen Sie Ihren code es tun.

Pseudo code könnte so etwas wie:
```
while (there are chunks in incoming array)
    copy 1 chunk to outbound array
    create uploadObject
    call webservice
endwhile
```
InformationsquelleAutor Albert

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.