인터페이스 목록을 직렬화하는 방법은 무엇입니까?

Question

일반 인터페이스에서 상속해야하는 객체를 얻었으며 해당 인터페이스의 속성 목록을 속성으로 가지고 있습니다.

XmlSerialzer가 내 MyClass.Items 목록 요소 안에있는 실제 형식을 결정할 수 없으므로 문제가 직렬화됩니다.

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

namespace MyTest 
{ 
    public interface IMyInterface 
    { 
     string TestProperty { get; set; } 
    } 
    public class MyClass : IMyInterface 
    { 
     public string TestProperty { get; set; } 
     public List<IMyInterface> Items { get; set; } 
    } 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      MyClass obj = new MyClass() { TestProperty = "Test" }; 
      XmlSerializer xs = new XmlSerializer(typeof(MyClass)); // <- throws System.NotSupportedException 
      using (XmlWriter xw = XmlWriter.Create("file.xml", new XmlWriterSettings() 
      { 
       Encoding = Encoding.UTF8, 
       Indent = true, 
       NewLineHandling = NewLineHandling.Entitize 
      })) 
      { 
       xs.Serialize(xw, obj); 
      } 
     } 
    } 
} 

T는 인터페이스 인 경우 List<T>을 어떻게 serialize 할 수 있습니까?

Answer 1

불행히도 그것은 기본적으로 지원되지 않지만 실행 가능합니다. IXmlSerializable 인터페이스를 사용하고 사용자 지정 직렬화를 작성해야합니다. 그다지 어렵지는 않습니다. 목록을 열거하고 각 객체의 기본 유형을 가져 와서이 유형의 새로운 XmlSerializer을 만들어야합니다. 비 직렬화는 런타임 유형을 결정하기 위해 클래스 이름을 구문 분석해야하므로 좀 더 까다로울 수 있습니다.

Answer 2

따라서 decPLs를 기반으로 대답을하고이 작업을 수행 할 클래스를 만들었습니다. T는 인터페이스가 있어야하며 작동합니다

public class InterfaceCollection<T> : Collection<T>, IXmlSerializable where T : class 
{ 
    private string Namespace { get; set; } 
    private string Assembly { get; set; } 

    public InterfaceCollection() 
    { 
    } 

    public InterfaceCollection(IList<T> list, string namespaceOfInheritedTypes = null, string assemblyOfInheritedTypes = null) 
     : base(list) 
    { 
     this.Namespace = namespaceOfInheritedTypes ?? null; 
     this.Assembly = assemblyOfInheritedTypes ?? null; 
    } 

    public InterfaceCollection(string namespaceOfInheritedTypes, string assemblyOfInheritedTypes = null) 
    { 
     this.Namespace = namespaceOfInheritedTypes ?? null; 
     this.Assembly = assemblyOfInheritedTypes ?? null; 
    } 

    public XmlSchema GetSchema() 
    { 
     return null; 
    } 

    public void ReadXml(XmlReader reader) 
    { 
     this.Namespace = reader.GetAttribute("fromNamespace"); 
     this.Assembly = reader.GetAttribute("fromAssembly"); 

     reader.MoveToContent(); 
     while (reader.Read()) 
     { 
      if (reader.NodeType == XmlNodeType.Element) 
      { 
       Type type; 
       if (this.Assembly != null) 
       { 
        type = Type.GetType(this.Namespace + "." + reader.Name + ", " + this.Assembly); 
       } 
       else 
       { 
        type = Type.GetType(this.Namespace + "." + reader.Name); 
       } 
       if (type != null) 
       { 
        XmlSerializer xs = XmlSerializer.FromTypes(new[] { type })[0]; 
        this.Items.Add((T)xs.Deserialize(reader)); 
       } 
      } 
     } 
    } 

    public void WriteXml(XmlWriter writer) 
    { 
     writer.WriteAttributeString("fromNamespace", this.Namespace); 
     if (this.Assembly != null) writer.WriteAttributeString("fromAssembly", this.Assembly); 
     foreach (T element in this) 
     { 
      Type type = element.GetType(); 
      XmlSerializer xs = XmlSerializer.FromTypes(new[] { type })[0]; 
      xs.Serialize(writer, element); 
     } 
    } 
}