Wie testen, ob mein Objekt wirklich serialisierbar ist?

Question

Ich benutze C# 2.0 mit Nunit Test. Ich habe ein Objekt, das serialisiert werden muss. Diese Objekte sind ziemlich komplex (Vererbung auf verschiedenen Ebenen und enthält viele Objekte, Ereignisse und Delegaten).

Wie kann ich einen Komponententest erstellen, um sicherzustellen, dass mein Objekt sicher serialisierbar ist?

Answer 1

Ich habe dies in einem gewissen Unit-Test hier bei 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); 
} 

Ihnen helfen könnte ... vielleicht andere Methode kann besser sein, aber diese funktioniert gut.

Answer 2

Zusätzlich zu dem obigen Test - der dafür sorgt, dass der Serializer Ihr Objekt akzeptiert, müssen Sie einen Round-Trip-Test durchführen. Deserialisieren Sie die Ergebnisse in ein neues Objekt und stellen Sie sicher, dass die beiden Instanzen äquivalent sind.

Answer 3

Serialisieren das Objekt (in dem Speicher oder Festplatte), deserialisieren es, die beide, dann Lauf alle der Komponententests für das Objekt wieder (außer Serialisierung natürlich) Verwendung Reflexion

zu vergleichen

Dies setzt voraus, dass Ihre Unit-Tests können ein Objekt als Ziel akzeptieren, anstatt ihre eigenen machen

Answer 4

Hier ist eine generische Art und Weise:

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

Hier ist eine Lösung, die IsSerializable rekursiv verwendet, dass das ob zu überprüfen Alle Eigenschaften sind serialisierbar.

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 6

Leider können Sie nicht wirklich dafür testen. Stellen Sie sich vor, diesen Fall:

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

ein bisschen spät am Tag Wahrscheinlich, aber wenn Sie die FluentAssertions Bibliothek verwenden, dann hat es benutzerdefinierte Behauptungen für XML-Serialisierung, binäre Serialisierung und Datenvertrag Serialisierung.