CODEWITHSUNDEEP
c#.netwcfserializationresponse
elucid8
elucid8

Reputation: 1422

Does WCF pad all byte arrays in SOAP messages?

I am doing some data chunking and I'm seeing an interesting issue when sending binary data in my response. I can confirm that the length of the byte array is below my data limit of 4 megabytes, but when I receive the message, it's total size is over 4 megabytes.

For the example below, I used the largest chunk size I could so I could illustrate the issue while still receiving a usable chunk.

Actual Message Size

The size of the binary data is 3,040,870 on the service side and the client (once the message is deserialized). However, I can also confirm that the byte array is actually just under 4 megabytes (this was done by actually copying the binary data from the message and pasting it into a text file).

Actual Size in Bytes

So, is WCF causing these issues and, if so, is there anything I can do to prevent it? If not, what might be causing this inflation on my side?

Thanks!

Upvotes: 0

Views: 833

Answers (2)

Brian
Brian

Reputation: 3713

If you're stuck with soap, you can offset the buffer overhead Tim S. talked about using the System.IO.Compression library in .Net - You'd use the compress function first, before building and sending the soap message.

You'd compress with this: 

public static byte[] Compress(byte[] data)
{
    MemoryStream ms = new MemoryStream();
    DeflateStream ds = new DeflateStream(ms, CompressionMode.Compress);
    ds.Write(data, 0, data.Length);
    ds.Flush();
    ds.Close();
    return ms.ToArray();
}

On the receiving end, you'd use this to decompress: 

public static byte[] Decompress(byte[] data)
{
    const int BUFFER_SIZE = 256;
    byte[] tempArray = new byte[BUFFER_SIZE];
    List<byte[]> tempList = new List<byte[]>();
    int count = 0;
    int length = 0;

    MemoryStream ms = new MemoryStream(data);
    DeflateStream ds = new DeflateStream(ms, CompressionMode.Decompress);

 while ((InlineAssignHelper(count, ds.Read(tempArray, 0, BUFFER_SIZE))) > 0) {
    if (count == BUFFER_SIZE) {
        tempList.Add(tempArray);
        tempArray = new byte[BUFFER_SIZE];
    } else {
        byte[] temp = new byte[count];
        Array.Copy(tempArray, 0, temp, 0, count);
        tempList.Add(temp);
    }
    length += count;
}

    byte[] retVal = new byte[length];

   count = 0;
   foreach (byte[] temp in tempList) {
        Array.Copy(temp, 0, retVal, count, temp.Length);
        count += temp.Length;
}

return retVal;
}

Upvotes: 0

Tim S.
Tim S.

Reputation: 56536

The usual way of sending byte[]s in SOAP messages is to base64-encode the data. This encoding takes 33% more space than binary encoding, which accounts for the size difference almost precisely.

You could adjust the max size or chunk size slightly so that the end result is within the right range, or use another encoding, e.g. MTOM, to eliminate this 33% overhead.

Upvotes: 3

Related Questions