Сериализация 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>();
    }
}

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

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

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

Интересная проблема и хорошее развлечение! :)

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

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

Интересная проблема и хорошее развлечение! :)

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

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

Интересная проблема и хорошее развлечение! :)