I have an object that contains tons of data used for reports. In order to get this object from the server to the client I first serialize the object in a memory stream, then compress it using the Gzip stream of .NET. I then send the compressed object as a byte[] to the client.

The problem is on some clients, when they get the byte[] and try to decompress and deserialize the object, a System.OutOfMemory exception is thrown. Ive read that this exception can be caused by new() a bunch of objects, or holding on to a bunch of strings. Both of these are happening during the deserialization process.

So my question is: How do I prevent the exception (any good strategies)? The client needs all of the data, and ive trimmed down the number of strings as much as i can.

edit: here is the code i am using to serialize/compress (implemented as extension methods)

public static byte[] SerializeObject<T>(this object obj, T serializer) where T: XmlObjectSerializer
    {
        Type t = obj.GetType();

        if (!Attribute.IsDefined(t, typeof(DataContractAttribute)))
            return null;

        byte[] initialBytes;

        using (MemoryStream stream = new MemoryStream())
        {
            serializer.WriteObject(stream, obj);
            initialBytes = stream.ToArray();
        }

        return initialBytes;
    }

    public static byte[] CompressObject<T>(this object obj, T serializer) where T : XmlObjectSerializer
    {
        Type t = obj.GetType();

        if(!Attribute.IsDefined(t, typeof(DataContractAttribute)))
            return null;

        byte[] initialBytes = obj.SerializeObject(serializer);

        byte[] compressedBytes;

        using (MemoryStream stream = new MemoryStream(initialBytes))
        {
            using (MemoryStream output = new MemoryStream())
            {
                using (GZipStream zipper = new GZipStream(output, CompressionMode.Compress))
                {
                    Pump(stream, zipper);
                }

                compressedBytes = output.ToArray();
            }
        }

        return compressedBytes;
    }

    internal static void Pump(Stream input, Stream output)
    {
        byte[] bytes = new byte[4096];
        int n;
        while ((n = input.Read(bytes, 0, bytes.Length)) != 0)
        {
            output.Write(bytes, 0, n);
        }
    }

And here is my code for decompress/deserialize:

public static T DeSerializeObject<T,TU>(this byte[] serializedObject, TU deserializer) where TU: XmlObjectSerializer
    {
        using (MemoryStream stream = new MemoryStream(serializedObject))
        {
            return (T)deserializer.ReadObject(stream);
        }
    }

    public static T DecompressObject<T, TU>(this byte[] compressedBytes, TU deserializer) where TU: XmlObjectSerializer
    {
        byte[] decompressedBytes;

        using(MemoryStream stream = new MemoryStream(compressedBytes))
        {
            using(MemoryStream output = new MemoryStream())
            {
                using(GZipStream zipper = new GZipStream(stream, CompressionMode.Decompress))
                {
                    ObjectExtensions.Pump(zipper, output);
                }

                decompressedBytes = output.ToArray();
            }
        }

        return decompressedBytes.DeSerializeObject<T, TU>(deserializer);
    }

The object that I am passing is a wrapper object, it just contains all the relevant objects that hold the data. The number of objects can be a lot (depending on the reports date range), but ive seen as many as 25k strings.

One thing i did forget to mention is I am using WCF, and since the inner objects are passed individually through other WCF calls, I am using the DataContract serializer, and all my objects are marked with the DataContract attribute.