XML-сериализация свойства интерфейса

решение этой проблемы заключается в использовании отражения с DataContractSerializer. Вам даже не нужно отмечать свой класс с помощью [DataContract] или [DataMember]. Он будет сериализовать любой объект, независимо от того, имеет ли он свойства типа интерфейса (включая словари) в xml. Вот простой метод расширения, который будет сериализовать любой объект в XML, даже если он имеет интерфейсы (обратите внимание, что вы можете настроить это для рекурсивного запуска).

    public static XElement ToXML(this object o)
    {
        Type t = o.GetType();

        Type[] extraTypes = t.GetProperties()
            .Where(p => p.PropertyType.IsInterface)
            .Select(p => p.GetValue(o, null).GetType())
            .ToArray();

        DataContractSerializer serializer = new DataContractSerializer(t, extraTypes);
        StringWriter sw = new StringWriter();
        XmlTextWriter xw = new XmlTextWriter(sw);
        serializer.WriteObject(xw, o);
        return XElement.Parse(sw.ToString());
    }

что делает выражение LINQ это перечисляет каждое свойство, возвращает каждое свойство, которое является интерфейсом, возвращает значение этого свойства (базовый объект), возвращает тип конкретного объекта помещает его в массив и добавляет его в список известных типов сериализатора.

теперь сериализатор знает, как насчет типов, которые он сериализует, чтобы он мог выполнять свою работу.

можно использовать ExtendedXmlSerializer. Этот сериализатор поддерживает сериализацию свойства интерфейса без каких-либо трюков.

var serializer = new ConfigurationContainer().UseOptimizedNamespaces().Create();

var obj = new Example
                {
                    Model = new Model { Name = "name" }
                };

var xml = serializer.Serialize(obj);

ваш XML будет выглядеть так:

<?xml version="1.0" encoding="utf-8"?>
<Example xmlns:exs="https://extendedxmlserializer.github.io/v2" xmlns="clr-namespace:ExtendedXmlSerializer.Samples.Simple;assembly=ExtendedXmlSerializer.Samples">
    <Model exs:type="Model">
        <Name>name</Name>
    </Model>
</Example>

ExtendedXmlSerializer поддерживает .net 4.5 и .net Core.

Если вы знаете, что ваши разработчики интерфейса впереди есть довольно простой хак, который вы можете использовать, чтобы получить тип интерфейса для сериализации без написания кода синтаксического анализа:

public interface IInterface {}
public class KnownImplementor01 : IInterface {}
public class KnownImplementor02 : IInterface {}
public class KnownImplementor03 : IInterface {}
public class ToSerialize {
  [XmlIgnore]
  public IInterface InterfaceProperty { get; set; }
  [XmlArray("interface")]
  [XmlArrayItem("ofTypeKnownImplementor01", typeof(KnownImplementor01)]
  [XmlArrayItem("ofTypeKnownImplementor02", typeof(KnownImplementor02)]
  [XmlArrayItem("ofTypeKnownImplementor03", typeof(KnownImplementor03)]
  public object[] InterfacePropertySerialization {
    get { return new[] { InterfaceProperty } }
    set { InterfaceProperty = (IInterface)value.Single(); }
  }
}

полученный xml должен выглядеть что-то вроде

 <interface><ofTypeKnownImplementor01><!-- etc... -->

замена интерфейса IModelObject абстрактным или конкретным типом и использование наследования с помощью XMLInclude возможно, но кажется уродливым обходным путем.

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

public abstract class IHaveSomething
{
    public abstract string Something { get; set; }
}

public class MySomething : IHaveSomething
{
    string _sometext;
    public override string Something 
    { get { return _sometext; } set { _sometext = value; } }
}

[XmlRoot("abc")]
public class seriaized
{
    [XmlElement("item", typeof(MySomething))]
    public IHaveSomething data;
}

к сожалению, нет простого ответа, так как сериализатор не знает, что сериализовать для интерфейса. Я нашел более полное объяснение о том, как обойти это на MSDN

в моем проекте, у меня есть
List FormatStyleTemplates;
содержит различные типы.

затем я использую решение "XmlAnything" сверху, чтобы сериализовать этот список различных типов. Сгенерированный xml-это красиво.

    [Browsable(false)]
    [EditorBrowsable(EditorBrowsableState.Never)]
    [XmlArray("FormatStyleTemplates")]
    [XmlArrayItem("FormatStyle")]
    public XmlAnything<IFormatStyle>[] FormatStyleTemplatesXML
    {
        get
        {
            return FormatStyleTemplates.Select(t => new XmlAnything<IFormatStyle>(t)).ToArray();
        }
        set
        {
            // read the values back into some new object or whatever
            m_FormatStyleTemplates = new FormatStyleProvider(null, true);
            value.ForEach(t => m_FormatStyleTemplates.Add(t.Value));
        }
    }

к сожалению для меня, у меня был случай, когда сериализуемый класс имел свойства, которые также имели интерфейсы как свойства, поэтому мне нужно было рекурсивно обрабатывать каждое свойство. Кроме того, некоторые свойства интерфейса были отмечены как [XmlIgnore], поэтому я хотел пропустить их. Я взял идеи, которые я нашел в этой теме, и добавил к ней некоторые вещи, чтобы сделать ее рекурсивной. Здесь показан только код десериализации:

void main()
{
    var serializer = GetDataContractSerializer<MyObjectWithCascadingInterfaces>();
    using (FileStream stream = new FileStream(xmlPath, FileMode.Open))
    {
        XmlDictionaryReader reader = XmlDictionaryReader.CreateTextReader(stream, new XmlDictionaryReaderQuotas());
        var obj = (MyObjectWithCascadingInterfaces)serializer.ReadObject(reader);

        // your code here
    }
}

DataContractSerializer GetDataContractSerializer<T>() where T : new()
{
    Type[] types = GetTypesForInterfaces<T>();

    // Filter out duplicates
    Type[] result = types.ToList().Distinct().ToList().ToArray();

    var obj = new T();
    return new DataContractSerializer(obj.GetType(), types);
}

Type[] GetTypesForInterfaces<T>() where T : new()
{
    return GetTypesForInterfaces(typeof(T));
}

Type[] GetTypesForInterfaces(Type T)
{
    Type[] result = new Type[0];
    var obj = Activator.CreateInstance(T);

    // get the type for all interface properties that are not marked as "XmlIgnore"
    Type[] types = T.GetProperties()
        .Where(p => p.PropertyType.IsInterface && 
            !p.GetCustomAttributes(typeof(System.Xml.Serialization.XmlIgnoreAttribute), false).Any())
        .Select(p => p.GetValue(obj, null).GetType())
        .ToArray();

    result = result.ToList().Concat(types.ToList()).ToArray();

    // do the same for each of the types identified
    foreach (Type t in types)
    {
        Type[] embeddedTypes = GetTypesForInterfaces(t);
        result = result.ToList().Concat(embeddedTypes.ToList()).ToArray();
    }
    return result;
}

Я нашел более простое решение (вам не нужен DataContractSerializer), благодаря этому блогу здесь: XML сериализация производных типов, когда базовый тип находится в другом пространстве имен или DLL

но 2 проблемы могут возникнуть в этой реализации:

(1) Что делать, если DerivedBase не находится в пространстве имен класса Base, или еще хуже в проекте, который зависит от базового пространства имен, поэтому Base не может XMLInclude DerivedBase

(2) что, если мы только есть база классов как dll, поэтому снова база не может XMLInclude DerivedBase

до сих пор ...

таким образом, решение двух проблем заключается в использовании XmlSerializer конструктор (тип, массив []):

XmlSerializer ser = new XmlSerializer(typeof(A), new Type[]{ typeof(DerivedBase)});

подробный пример приведен здесь на MSDN: конструктор XmlSerializer (Type, extraTypesArray [])

Мне кажется, что для DataContracts или Soap XMLs вам нужно Регистрация XmlRoot, как упоминалось здесь в этом вопросе SO.

A подобный ответ здесь на SO но он не помечен как один, так как это не OP, похоже, уже рассмотрел его.