Сериализация XML и наследуемые типы

Проблема Решена!

хорошо, так что я, наконец, добрался туда (по общему признанию, с много С здесь!).

Итак, подведем итог:

цели:

• я не хотел спускаться XmlInclude маршрут из-за головной боли обслуживания.
• как только решение было найдено, я хотел, чтобы оно было быстро реализовано в других приложениях.
• коллекции абстрактных типов могут быть использованы, как а также отдельные абстрактные свойства.
• я действительно не хотел беспокоиться о том, чтобы делать "специальные" вещи в конкретных классах.

выявленные проблемы / пункты, чтобы отметить:

• XmlSerializer делает некоторые довольно прохладно отражение, но это очень ограничено, когда речь заходит об абстрактных типах (т. е. он будет работать только с экземплярами самого абстрактного типа, а не подклассов).
• Xml декораторы атрибутов определяют, как XmlSerializer обрабатывает свойства, которые он находит. Физический тип также может быть указан, но это создает жесткая связь между классом и сериализатором (не очень хорошо).
• мы можем реализовать наш собственный XmlSerializer, создав класс, который реализует IXmlSerializable .

Решение

Я создал универсальный класс, в котором вы указываете универсальный тип как абстрактный тип вы будете работать вместе. Это дает классу возможность "переводить" между абстрактным типом и конкретным типом, поскольку мы можем жестко кодировать литье (т. е. мы можем получить больше информации, чем XmlSerializer).

Я тогда реализовал IXmlSerializable интерфейс, это довольно прямолинейно, но при сериализации нам нужно убедиться, что мы пишем тип конкретного класса в XML, поэтому мы можем отбросить его при де-сериализации. Также важно отметить это должно быть полное поскольку сборки, в которых находятся два класса, скорее всего, будут отличаться. Есть, конечно, немного проверки типа и прочее, что должно произойти здесь.

поскольку XmlSerializer не может привести, нам нужно предоставить код для этого, поэтому неявный оператор затем перегружается (я даже не знал, что вы можете это сделать!).

код для AbstractXmlSerializer таков:

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

Итак, оттуда, как мы скажем XmlSerializer для работы с нашим сериализатором, а не по умолчанию? Мы должны передать наш тип в свойстве тип атрибутов Xml, например:

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

здесь вы можете видеть, что у нас есть коллекция и одно свойство подвергается, и все, что нам нужно сделать, это добавить тип именованный параметр для объявления Xml, легко! : D

Примечание: Если вы используете этот код, я был бы очень признателен кричать. Это также поможет привлечь больше людей в сообщество :)

теперь, но не уверен, что делать с ответами здесь, так как у всех были свои плюсы и минусы. я буду upmod те, которые я чувствую, были полезны (без обид на тех, кто не был) и закрыть это, как только у меня есть репутация:)

интересные задачи и хорошее удовольствие, чтобы решить! :)