Comment faire un test unitaire si mon objet est vraiment sérialisable?

Voici une voie Générique:

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));
}

en plus du test ci - dessus-qui assure que le serializer acceptera votre objet, vous devez faire un test aller-retour. Désérialisez les résultats vers un nouvel objet et assurez-vous que les deux instances sont équivalentes.

sérialiser l'objet (en mémoire ou sur disque), le desérialiser, utiliser la réflexion pour comparer les deux, puis exécuter à nouveau tous les tests unitaires pour cet objet (sauf la sérialisation bien sûr)

cela suppose que vos tests unitaires peuvent accepter un objet comme cible au lieu de faire leur propre

Voici une solution qui utilise de façon récursive Isserialisable pour vérifier que l'objet et toutes ses propriétés sont sérialisables.

    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);
        }
    }

malheureusement, vous ne pouvez pas vraiment tester pour cela. Imaginez ce cas:

[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
}

probablement un peu en retard dans la journée, mais si vous utilisez la bibliothèque FluentAssertions , alors il a des assertions personnalisées pour la sérialisation XML, la sérialisation binaire, et la sérialisation de contrat de données.

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

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