Sérialisation XML et types hérités

Problème Résolu!

OK, donc j'y suis finalement arrivé (il est vrai avec un lot d'aide de ici !).

en résumé:

Objectifs:

• Je n'ai pas voulu suivre la route XmlInclude à cause des maux de tête de maintien.
• une fois qu'une solution a été trouvée, je voulais qu'il soit rapide à mettre en œuvre dans d'autres applications.
• des Collections de types abstraits peuvent être utilisées, ainsi que des propriétés abstraites individuelles.
• Je ne voulais pas vraiment m'embêter à faire des choses" spéciales " dans les classes de béton.

questions soulevées / points à noter:

• XmlSerializer fait assez cool de réflexion, mais il est très limité lorsqu'il s'agit de types abstraits (c'est-à-dire qu'il ne fonctionne qu'avec des instances du type abstrait lui-même, et non avec des sous-classes).
• l'attribut Xml decorators définit comment XmlSerializer traite les propriétés de ses objets trouvés. Le type physique peut également être spécifié, mais cela crée un couplage serré entre la classe et le serializer (pas bon).
• nous pouvons implémenter notre propre XmlSerializer en créant une classe qui implémente IXmlSerializable .

La Solution

j'ai créé une classe générique, dans laquelle vous indiquez le type générique comme le type abstrait, vous allez travailler avec. Cela donne à la classe la capacité de "traduire" entre le type abstrait et le type concret puisque nous pouvons coder dur le moulage (i.e. nous pouvons obtenir plus d'informations que le XmlSerializer peut).

j'ai ensuite mis en place le Ixmlserialisable interface, c'est assez simple, mais lors de la sérialisation, nous devons nous assurer d'écrire le type de la classe de béton au XML, de sorte que nous pouvons le jeter en arrière lors de la désérialisation. Il est également important de noter qu'il doit être pleinement qualifié car les ensembles dans lesquels les deux classes sont susceptibles de différer. Il y a bien sûr une petite vérification de type et des choses qui doivent se produire ici.

puisque le XmlSerializer ne peut pas cast, nous avons besoin de fournir le code pour le faire, alors l'opérateur implicite est alors surchargé (je ne savais même pas que vous pourriez le faire!).

le code de L'AbstractXmlSerializer est le suivant:

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

namespace Utility.Xml
{
    public class AbstractXmlSerializer<AbstractType> : IXmlSerializable
    {
        // Override the Implicit Conversions Since the XmlSerializer
        // Casts to/from the required types implicitly.
        public static implicit operator AbstractType(AbstractXmlSerializer<AbstractType> o)
        {
            return o.Data;
        }

        public static implicit operator AbstractXmlSerializer<AbstractType>(AbstractType o)
        {
            return o == null ? null : new AbstractXmlSerializer<AbstractType>(o);
        }

        private AbstractType _data;
        /// <summary>
        /// [Concrete] Data to be stored/is stored as XML.
        /// </summary>
        public AbstractType Data
        {
            get { return _data; }
            set { _data = value; }
        }

        /// <summary>
        /// **DO NOT USE** This is only added to enable XML Serialization.
        /// </summary>
        /// <remarks>DO NOT USE THIS CONSTRUCTOR</remarks>
        public AbstractXmlSerializer()
        {
            // Default Ctor (Required for Xml Serialization - DO NOT USE)
        }

        /// <summary>
        /// Initialises the Serializer to work with the given data.
        /// </summary>
        /// <param name="data">Concrete Object of the AbstractType Specified.</param>
        public AbstractXmlSerializer(AbstractType data)
        {
            _data = data;
        }

        #region IXmlSerializable Members

        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null; // this is fine as schema is unknown.
        }

        public void ReadXml(System.Xml.XmlReader reader)
        {
            // Cast the Data back from the Abstract Type.
            string typeAttrib = reader.GetAttribute("type");

            // Ensure the Type was Specified
            if (typeAttrib == null)
                throw new ArgumentNullException("Unable to Read Xml Data for Abstract Type '" + typeof(AbstractType).Name +
                    "' because no 'type' attribute was specified in the XML.");

            Type type = Type.GetType(typeAttrib);

            // Check the Type is Found.
            if (type == null)
                throw new InvalidCastException("Unable to Read Xml Data for Abstract Type '" + typeof(AbstractType).Name +
                    "' because the type specified in the XML was not found.");

            // Check the Type is a Subclass of the AbstractType.
            if (!type.IsSubclassOf(typeof(AbstractType)))
                throw new InvalidCastException("Unable to Read Xml Data for Abstract Type '" + typeof(AbstractType).Name +
                    "' because the Type specified in the XML differs ('" + type.Name + "').");

            // Read the Data, Deserializing based on the (now known) concrete type.
            reader.ReadStartElement();
            this.Data = (AbstractType)new
                XmlSerializer(type).Deserialize(reader);
            reader.ReadEndElement();
        }

        public void WriteXml(System.Xml.XmlWriter writer)
        {
            // Write the Type Name to the XML Element as an Attrib and Serialize
            Type type = _data.GetType();

            // BugFix: Assembly must be FQN since Types can/are external to current.
            writer.WriteAttributeString("type", type.AssemblyQualifiedName);
            new XmlSerializer(type).Serialize(writer, _data);
        }

        #endregion
    }
}

donc, à partir de là, comment dire au XmlSerializer de travailler avec notre serializer plutôt que par défaut? Nous devons passer notre type dans la propriété Xml attributes type, par exemple:

[XmlRoot("ClassWithAbstractCollection")]
public class ClassWithAbstractCollection
{
    private List<AbstractType> _list;
    [XmlArray("ListItems")]
    [XmlArrayItem("ListItem", Type = typeof(AbstractXmlSerializer<AbstractType>))]
    public List<AbstractType> List
    {
        get { return _list; }
        set { _list = value; }
    }

    private AbstractType _prop;
    [XmlElement("MyProperty", Type=typeof(AbstractXmlSerializer<AbstractType>))]
    public AbstractType MyProperty
    {
        get { return _prop; }
        set { _prop = value; }
    }

    public ClassWithAbstractCollection()
    {
        _list = new List<AbstractType>();
    }
}

ici vous pouvez voir, nous avons un collection et une seule propriété étant exposée, et tout ce que nous avons à faire est d'ajouter le paramètre type nommé à la déclaration Xml, facile! : D

NOTE: Si vous utilisez ce code, j'apprécierais vraiment un shout-out. Il sera également aider à conduire plus de gens à la communauté :)

maintenant, mais pas sûr de savoir quoi faire avec les réponses ici car ils ont tous eu leur pour et con. Je soulèverai ceux que je sens étaient utile (aucune offense à ceux qui ne l'étaient pas) et fermer cette une fois que j'ai le rep:)

problème intéressant et bon plaisir à résoudre! :)