XmlSerializer serialize generic Lista de interfaz

Question

Estoy tratando de usar el XmlSerializer para mantener una Lista (T) donde T es una interfaz. El serializador no le gusta las interfaces. Tengo curiosidad por saber si existe una forma sencilla de serializar fácilmente una lista de objetos heterogéneos con XmlSerializer. Esto es lo que estoy buscando:

public interface IAnimal 
    { 
     int Age(); 
    } 
    public class Dog : IAnimal 
    { 
     public int Age() 
     { 
      return 1; 
     } 
    } 
    public class Cat : IAnimal 
    { 
     public int Age() 
     { 
      return 1; 
     } 
    } 

    private void button1_Click(object sender, RoutedEventArgs e) 
    { 
     var animals = new List<IAnimal> 
     { 
      new Dog(), 
      new Cat() 
     }; 

     var x = new XmlSerializer(animals.GetType()); 
     var b = new StringBuilder(); 
     var w = XmlTextWriter.Create(b, new XmlWriterSettings { NewLineChars = "\r\n", Indent = true }); 
     //FAIL - cannot serialize interface. Does easy way to do this exist? 
     x.Serialize(w, animals); 
     var s = b.ToString();  
    } 

Answer 1

¿Tienes que usar XmlSerializer? Este es un problema conocido con XmlSerializer.

Puede utilizar BinaryFormatter para salvar a una corriente:

BinaryFormatter bf = new BinaryFormatter(); 
MemoryStream ms = new MemoryStream(); 
bf.Serialize(ms, animals); 

Otra alternativa es utilizar WCF de DataContractSerializer y proporcionar tipos de atributos usando KnownType.

Answer 2

También puede usar XmlSerializer, pero debe incluir todos los tipos posibles que pueden aparecer en el gráfico de objetos que está serializando, lo que limita la extensibilidad y reduce el mantenimiento. Puede hacerlo mediante el uso de una sobrecarga del constructor de XmlSerializer:

var x = new XmlSerializer(animals.GetType(), new Type[] { typeof(Cat), typeof(Dog) }); 

Además, hay varias cuestiones de la nota cuando se usa XmlSerializer, toda la here (MSDN) esbozado - por ejemplo, busque bajo el título 'asambleas generados dinámicamente' .

Answer 3

El XmlSerializer no puede manejar una interfaz porque no sabe qué tipos crear al deserializar. Para evitar esto, debe manejar esa parte de la serialización implementando la interfaz IXmlSerializable. Esto le permite grabar el tipo para que pueda volver a crearlo (deserializarlo).

La clase ListOfIAnimal a continuación muestra cómo heredé y extendí la lista genérica List<IAnimal> para implementar la interfaz requerida. Comprimí tus viejas clases y agregué un campo extra sin interfaz para cada una de ellas, así pude ver que las clases concretas estaban siendo serializadas y deserializadas apropiadamente.

En comparación con su código, estoy usando el nuevo tipo ListOfIAnimal en lugar de List<IAnimal>, los otros cambios son solo un poco de refactorización.

Su código completo, simplemente cópielo en su propio archivo .cs, llame a la primera función para recorrerlo.

using System; 
using System.Collections.Generic; 
using System.IO; 
using System.Text; 
using System.Xml; 
using System.Xml.Serialization; 

namespace Serialiser 
{ 
    static class SerialiseInterface 
    { 
     public static void SerialiseAnimals() 
     { 
      String finalXml; 

      // Serialize 
      { 
       var animals = new ListOfIAnimal{ 
        new Dog() { Age = 5, Teeth = 30 }, 
        new Cat() { Age = 6, Paws = 4 } 
       }; 

       var xmlSerializer = new XmlSerializer(animals.GetType()); 
       var stringBuilder = new StringBuilder(); 
       var xmlTextWriter = XmlTextWriter.Create(stringBuilder, new XmlWriterSettings { NewLineChars = "\r\n", Indent = true }); 
       xmlSerializer.Serialize(xmlTextWriter, animals); 
       finalXml = stringBuilder.ToString(); 
      } 

      // Deserialise 
      { 
       var xmlSerializer = new XmlSerializer(typeof(ListOfIAnimal)); 
       var xmlReader = XmlReader.Create(new StringReader(finalXml)); 
       ListOfIAnimal animals = (ListOfIAnimal)xmlSerializer.Deserialize(xmlReader); 
      } 
     } 
    } 

    public class ListOfIAnimal : List<IAnimal>, IXmlSerializable 
    { 
     public ListOfIAnimal() : base() { } 

     #region IXmlSerializable 
     public System.Xml.Schema.XmlSchema GetSchema() { return null; } 

     public void ReadXml(XmlReader reader) 
     { 
      reader.ReadStartElement("ListOfIAnimal"); 
      while (reader.IsStartElement("IAnimal")) 
      { 
       Type type = Type.GetType(reader.GetAttribute("AssemblyQualifiedName")); 
       XmlSerializer serial = new XmlSerializer(type); 

       reader.ReadStartElement("IAnimal"); 
       this.Add((IAnimal)serial.Deserialize(reader)); 
       reader.ReadEndElement(); //IAnimal 
      } 
      reader.ReadEndElement(); //ListOfIAnimal 
     } 

     public void WriteXml(XmlWriter writer) 
     { 
      foreach (IAnimal animal in this) 
      { 
       writer.WriteStartElement("IAnimal"); 
       writer.WriteAttributeString("AssemblyQualifiedName", animal.GetType().AssemblyQualifiedName); 
       XmlSerializer xmlSerializer = new XmlSerializer(animal.GetType()); 
       xmlSerializer.Serialize(writer, animal); 
       writer.WriteEndElement(); 
      } 
     } 
     #endregion 
    } 

    public interface IAnimal { int Age { get; set; } } 
    public class Dog : IAnimal { public int Age { get; set;} public int Teeth { get; set;} } 
    public class Cat : IAnimal { public int Age { get; set;} public int Paws { get; set;} } 
} 

pensé en dejar deserializar como ejercicio para el lector, pero el código would'n ser muy útil sin ella.

Answer 4

La manera fácil es agregar la decoración [Serializable()] a sus clases y cambiar su IList a List y ver si eso funciona.

Si usa interfaces, vaya a la respuesta del webturner.

Answer 5

Puede usar ExtendedXmlSerializer.

var serializer = new ExtendedXmlSerializer(); 
var xml = serializer.Serialize(animals); 

el código XML se verá así:

<?xml version="1.0" encoding="utf-8"?> 
<ArrayOfIAnimal> 
    <Dog type="Model.Dog" /> 
    <Cat type="Model.Cat" /> 
</ArrayOfIAnimal>