Can serializing the same object produce different streams?

Question

Is there any situation when serializing the same object could produce different streams (assuming one of the formatters built-in .NET is used for both serializations)?

This came up in the discussion below this post. The claim was made that this can happen, yet no concrete explanation was offered, so I was wondering if anyone can shed some light on the issue?

Answer 1

As I explained in the comment of that SO question, the issue is caused (at least the case I have discovered) by optimisation of the string output. It seems if strings are the same reference, then it will output it once.

So what we the sample code does it to use a long string for properties of an object and change the reference of one string and then serialise. Then deserialise the stream back again to object (and this time since the string is interned, same reference is used) and then serialise again. This time the stream is smaller.

OK, here is the proof code:

[Serializable]
public class Proof
{
    public string S1 { get; set; }
    public string S2 { get; set; }
    public string S3 { get; set; }
}

class Program
{
    static void Main(string[] args)
    {

        const string LongString =
            "A value that is going to change the world nad iasjdsioajdsadj sai sioadj sioadj siopajsa iopsja iosadio jsadiojasd ";

        var proof = new Proof() {
            S1 = LongString,
            S2 = LongString,
            S3 = LongString
        };

        proof.S2 = LongString.Substring(0, 10) + LongString.Substring(10); // just add up first 10 character with the rest. 
               //This just makes sure reference is not the same although values will be

        Console.WriteLine(proof.S1 == proof.S2);
        Console.WriteLine(proof.S1 == proof.S3);
        Console.WriteLine(proof.S2 == proof.S3);
        Console.WriteLine("So the values are all the same...");

        BinaryFormatter bf = new BinaryFormatter();
        MemoryStream stream = new MemoryStream();
        bf.Serialize(stream, proof);
        byte[] buffer = stream.ToArray();
        Console.WriteLine("buffer length is " + buffer.Length); // outputs 449 on my machine
        stream.Position = 0;
        var deserProof = (Proof) bf.Deserialize(new MemoryStream(buffer));
        deserProof.S1 = deserProof.S2;
        deserProof.S3 = deserProof.S2;
        MemoryStream stream2 = new MemoryStream();
        new BinaryFormatter().Serialize(stream2, deserProof);

        Console.WriteLine("buffer length now is " + stream2.ToArray().Length); // outputs 333 on my machine!!
        Console.WriteLine("What? I cannot believe my eyes! Someone help me ........");

        Console.Read();
    }

Answer 2

Some core types (DateTime - noting in particular the "kind", or Decimal noting the scale) could have values that report as equal, but which serialize differently; for example:

using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
[Serializable]
class Foo
{
    public decimal Bar { get; set; }
    static void Main()
    {
        Foo foo = new Foo();
        foo.Bar = 123.45M;
        var s = Serialize(foo);

        Foo foo2 = new Foo();
        foo2.Bar = 123.4500M;

        bool areSame = foo.Bar == foo2.Bar; // true
        var s2 = Serialize(foo2);

        bool areSerializedTheSame = s == s2; // false
    }
    static string Serialize(object obj)
    {
        using (var ms = new MemoryStream())
        {
            new BinaryFormatter().Serialize(ms, obj);
            return Convert.ToBase64String(ms.GetBuffer(), 0, (int)ms.Length);
        }
    }
}

As to whether the exact same object could serialize differently - well, that isn't usually a guarantee that serialization makes any claim about. Serialization is about storing and retrieving your data/objects - not about proving equality. For example, xml has all kinds of whitespace and namespace normalization issues that make it unsuitable for comparison. BinaryFormatter and other binary serializers look more tempting, but I'm not sure that they guarantee the behaviour you are looking for.

I would not really trust a comparison made via such an approach unless the serializer explicitly made this guarantee.

Answer 3

Depends a little on what you call the 'same' object.

But yes, 2 instances could compare as Equal=true and still produce different streams.

• very trivially with a broken or limited override of Equals
• because of subtle differences caused by normalizations or the order of operations.

I verified that adding the same elements to a Dictionary in a different order produces a different stream. I assume you would consider 2 dictionaries with the same content 'equal'.