How to unit test if my object is really serializable?

Question

I am using C# 2.0 with Nunit Test. I have some object that needs to be serialized. These objects are quite complex (inheritance at different levels and contains a lot of objects, events and delegates).

How can I create a Unit Test to be sure that my object is safely serializable?

Alrzc

Answer 1

I have this in some unit test here at job:

MyComplexObject dto = new MyComplexObject();
MemoryStream mem = new MemoryStream();
BinaryFormatter b = new BinaryFormatter();
try
{
    b.Serialize(mem, dto);
}
catch (Exception ex)
{
    Assert.Fail(ex.Message);
}

Might help you... maybe other method can be better but this one works well.

Hermineherminia

You need to be careful of NonSerialized (or transient in java) objects though, and those should be tested as part of your serialization and deserialization. – Minda

@Minda there are no NonSerialized objects, only NonSerialized fields. – Engorge

BinaryFormatter is obsolete in .Net6. Suggestions for .Net6? learn.microsoft.com/en-us/dotnet/fundamentals/… – Apfelstadt

Answer 2

Here is a generic way:

public static Stream Serialize(object source)
{
    IFormatter formatter = new BinaryFormatter();
    Stream stream = new MemoryStream();
    formatter.Serialize(stream, source);
    return stream;
}

public static T Deserialize<T>(Stream stream)
{
    IFormatter formatter = new BinaryFormatter();
    stream.Position = 0;
    return (T)formatter.Deserialize(stream);
}

public static T Clone<T>(object source)
{
    return Deserialize<T>(Serialize(source));
}

Sachiko

works perfectly. Comparing the original to the Cloned copy is a great test of serialization as checking IsSerializable only checks the attribute of the class and not base class or other properties – Gangplank

If you change the signature of the clone method to public static T Clone<T>(T source) you get proper type inference for free. – Maritsa

Answer 3

In addition to the test above - which makes sure the serializer will accept your object, you need to do a round-trip test. Deserialize the results back to a new object and make sure the two instances are equivalent.

Sarette

Answer 4

Probably a bit late in the day, but if you are using the FluentAssertions library, then it has custom assertions for XML serialization, binary serialization, and data contract serialization.

theObject.Should().BeXmlSerializable();
theObject.Should().BeBinarySerializable();
theObject.Should().BeDataContractSerializable();

theObject.Should().BeBinarySerializable<MyClass>(
    options => options.Excluding(s => s.SomeNonSerializableProperty));

Angelika

Answer 5

serialize the object (to memory or disk), deserialize it, use reflection to compare the two, then run all of the unit tests for that object again (except serialization of course)

this assumes that your unit tests can accept an object as a target instead of making their own

Pad

I always comment on a down vote. You don't need to run tests again if the two have equivalent data. Beyond that when comparing data you have to understand that sometimes data changes when serializing/deserializing and need a way of expressing this (think about things that use the memento pattern like serializing a form the two may be equivalent after even though all the data is not the same) – Dejong

@Greg: serilization is supposed to be identical, but as you point out may have fluctuations. The serialization routines and the comparison routines may also be incomplete or flawed, hence the recommendation to run all of the unit tests again. If they all pass on the reconstituted object, it's good to go. If they don't, this will indicate places where rehydration (and/or comparison) failed. – Pad

Answer 6

Here is a solution that recursively uses IsSerializable to check that the object and all its properties are Serializable.

    private static void AssertThatTypeAndPropertiesAreSerializable(Type type)
    {
        // base case
        if (type.IsValueType || type == typeof(string)) return;

        Assert.IsTrue(type.IsSerializable, type + " must be marked [Serializable]");

        foreach (var propertyInfo in type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
        {
            if (propertyInfo.PropertyType.IsGenericType)
            {
                foreach (var genericArgument in propertyInfo.PropertyType.GetGenericArguments())
                {
                    if (genericArgument == type) continue; // base case for circularly referenced properties
                    AssertThatTypeAndPropertiesAreSerializable(genericArgument);
                }
            }
            else if (propertyInfo.GetType() != type) // base case for circularly referenced properties
                AssertThatTypeAndPropertiesAreSerializable(propertyInfo.PropertyType);
        }
    }

Fussell

The generic arguments don't need to be serializable for a type to be, for example ObjectComparer<NonSerialiableType> is serializable. – Blab

Answer 7

Unfortunately, you can't really test for this. Imagine this case:

[Serializable]
class Foo {
    public Bar MyBar { get; set; }
}

[Serializable]
class Bar {
    int x;
}

class DerivedBar : Bar {
}

public void TestSerializeFoo() {
    Serialize(new Foo()); // OK
    Serialize(new Foo() { MyBar = new Bar() }; // OK
    Serialize(new Foo() { MyBar = new DerivedBar() }; // Boom
}

Blab

how can you assign DerivedBar to MyBar? – Coomer