如何对我的对象是否真的可序列化进行单元测试？

Question

我正在使用 C# 2.0 和 Nunit Test。 我有一些需要序列化的对象。 这些对象相当复杂（不同级别的继承并且包含很多对象、事件和委托）。

如何创建单元测试以确保我的对象可以安全地序列化？

Answer 1

序列化对象（到内存或磁盘），反序列化它，使用反射来比较两者，然后再次运行该对象的所有单元测试（当然序列化除外），

这假设您的单元测试可以接受一个物体作为目标而不是制作自己的目标

Answer 2

下面是一个解决方案，递归地使用 IsSerialized 来检查对象及其所有属性是否可序列化。

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

Answer 3

不幸的是，您无法真正对此进行测试。 想象一下这个案例：

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

Answer 4

这是一个通用的方法：

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

Answer 5

我在工作中的一些单元测试中有这个：

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

可能会帮助你......也许其他方法可能更好，但这个效果很好。

Answer 6

除了上面的测试（确保序列化器接受您的对象）之外，您还需要进行往返测试。 将结果反序列化回新对象并确保两个实例是等效的。

Answer 7

可能有点晚了，但是如果您使用 FluentAssertions 库，那么它有自定义断言用于 XML 序列化、二进制序列化和数据协定序列化。

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

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