Abstract class 如何为ICollection正确实现IXmlSerializable<；T>；其中T是一个抽象类？

我试图在T的集合中实现IXmlSerializable接口，其中T是一个抽象类。 我的设想是：

我有一个抽象类基类，它实现了IXmlSerializable

从基类继承的两个派生类（Deriv01、Deriv02） 并重写方法以正确实现WriteXml和 ReadXml

基类的集合（BaseClassCollection），它是 ICollection，还实现IXmlSerializable

集合的序列化工作得很好，但我一直在进行反序列化，我不知道如何实现它，我希望您能提供帮助

这是我的实现：

[XmlInclude(typeof(Deriv01))]
[XmlInclude(typeof(Deriv02))]
[XmlType("base")]
public abstract class BaseClass : IXmlSerializable
{
    private int _a;
    private string _b;

    public int A
    {
        get { return this._a; }
    }
    public string B
    {
        get { return this._b; }
    }

    protected BaseClass()
    {
        this._b = string.Empty;
    }
    protected BaseClass(int a, string b)
    {
        this._a = a;
        this._b = !string.IsNullOrEmpty(b) ? b : string.Empty;
    }

    protected virtual void WriteXmlAttributes(XmlWriter writer)
    {
        if (writer == null) throw new ArgumentNullException("writer");
        writer.WriteAttributeString("a", XmlConvert.ToString(this._a));
    }
    protected virtual void WriteXmlElements(XmlWriter writer)
    {
        if (writer == null) throw new ArgumentNullException("writer");
        writer.WriteStartElement("b");
        writer.WriteString(this._b);
        writer.WriteEndElement();
    }
    protected virtual void ReadXmlAttributes(XmlReader reader)
    {
        if (reader == null) throw new ArgumentNullException("reader");
        int a;
        this._a = int.TryParse(reader["a"], out a) ? a : 0;
    }
    protected virtual void ReadXmlElements(XmlReader reader)
    {
        if (reader == null) throw new ArgumentNullException("reader");

        reader.Read();
        if (!reader.IsStartElement("b")) return;
        this._b = reader.ReadString();
        reader.ReadEndElement();
    }

    #region Implementation of IXmlSerializable
    public XmlSchema GetSchema()
    {
        return null;
    }
    public void ReadXml(XmlReader reader)
    {
        if (reader == null) throw new ArgumentNullException("reader");

        ReadXmlAttributes(reader);
        ReadXmlElements(reader);
    }
    public void WriteXml(XmlWriter writer)
    {
        if (writer == null) throw new ArgumentNullException("writer");
        WriteXmlAttributes(writer);
        WriteXmlElements(writer);
    }
    #endregion
}

[XmlType("deriv01")]
public class Deriv01 : BaseClass
{
    private int _c;

    public int C
    {
        get { return this._c; }
    }

    public Deriv01()
    { }
    public Deriv01(int a, string b, int c)
        : base(a, b)
    {
        this._c = c;
    }

    protected override void WriteXmlAttributes(XmlWriter writer)
    {
        if (writer == null) throw new ArgumentNullException("writer");
        base.WriteXmlAttributes(writer);
        writer.WriteAttributeString("c", XmlConvert.ToString(this._c));

        writer.WriteAttributeString("xsi", "type", "http://www.w3.org/2001/XMLSchema-instance", "deriv01");
    }
    protected override void ReadXmlAttributes(XmlReader reader)
    {
        if (reader == null) throw new ArgumentNullException("reader");
        base.ReadXmlAttributes(reader);
        int c;
        this._c = int.TryParse(reader["c"], out c) ? c : 0;
    }
}

[XmlType("deriv02")]
public class Deriv02 : BaseClass
{
    private int _d;

    public int D
    {
        get { return this._d; }
    }

    public Deriv02()
    {
    }
    public Deriv02(int a, string b, int d)
        : base(a, b)
    {
        this._d = d;
    }
    protected override void WriteXmlElements(XmlWriter writer)
    {
        if (writer == null) throw new ArgumentNullException("writer");
        base.WriteXmlElements(writer);
        writer.WriteElementString("d", XmlConvert.ToString(this._d));
    }
    protected override void ReadXmlElements(XmlReader reader)
    {
        if (reader == null) throw new ArgumentNullException("reader");
        base.ReadXmlElements(reader);
        int d;
        if (!reader.IsStartElement("d")) return;
        this._d = int.TryParse(reader.ReadString(), out d) ? d : 0;
        reader.ReadEndElement();
    }
    protected override void WriteXmlAttributes(XmlWriter writer)
    {
        if (writer == null) throw new ArgumentNullException("writer");
        base.WriteXmlAttributes(writer);
        writer.WriteAttributeString("xsi", "type", "http://www.w3.org/2001/XMLSchema-instance", "deriv02");
    }
}

[XmlRoot("elementos")]
public class BaseClassCollection : ICollection<BaseClass>, IXmlSerializable
{
    private List<BaseClass> _elementos = new List<BaseClass>();

    public BaseClass this[int index]
    {
        get { return this._elementos[index]; }
    }

    public BaseClassCollection()
    { }

    #region Implementation of ICollection<BaseClass>
    public void Add(BaseClass item)
    {
        if (this._elementos.Contains(item)) return;
        this._elementos.Add(item);
    }
    public void Clear()
    {
        this._elementos.Clear();
    }
    public bool Contains(BaseClass item)
    {
        return this._elementos.Contains(item);
    }
    public void CopyTo(BaseClass[] array, int arrayIndex)
    {
        this._elementos.CopyTo(array, arrayIndex);
    }
    public bool Remove(BaseClass item)
    {
        return this._elementos.Remove(item);
    }
    public int Count
    {
        get { return this._elementos.Count; }
    }
    public bool IsReadOnly
    {
        get { return false; }
    }
    #endregion

    #region Implementation of IEnumerable
    public IEnumerator<BaseClass> GetEnumerator()
    {
        foreach (BaseClass elemento in this._elementos)
        {
            yield return elemento;
        }
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
    #endregion

    #region Implementation of IXmlSerializable
    public XmlSchema GetSchema()
    {
        return null;
    }
    public void ReadXml(XmlReader reader)
    {
        if (reader == null) throw new ArgumentNullException("reader");

        XmlSerializer inner = new XmlSerializer(typeof(BaseClassCollection));
        reader.Read();
        while (reader.NodeType != XmlNodeType.EndElement)
        {
            //This line don't work
            BaseClass item = (BaseClass) inner.Deserialize(reader);
            this._elementos.Add(item);
        }
        reader.ReadEndElement();
    }
    public void WriteXml(XmlWriter writer)
    {
        if (writer == null) throw new ArgumentNullException("writer");
        writer.WriteAttributeString("xmlns", "xsi", null, "http://www.w3.org/2001/XMLSchema-instance");
        writer.WriteAttributeString("xmlns", "xsd", null, "http://www.w3.org/2001/XMLSchema");

        writer.WriteAttributeString("cont", XmlConvert.ToString(this._elementos.Count));

        foreach(BaseClass item in this._elementos)
        {
            writer.WriteStartElement("elemento");
            item.WriteXml(writer);
            writer.WriteEndElement();
        }
    }
    #endregion
}


public void ReadXml(XmlReader reader)
{
    if (reader == null) throw new ArgumentNullException("reader");

    BaseClass item = null;
    reader.Read();
    while (reader.NodeType != XmlNodeType.EndElement)
    {
       string type = reader["type", "http://www.w3.org/2001/XMLSchema-instance"];
       switch (type)
       {
           case "deriv01":
               item = new Deriv01();
               break;
           case "deriv02":
               item = new Deriv02();
               break;
       }
       if (item == null) continue;
       item.ReadXml(reader);
       this._elementos.Add(item);
       reader.ReadEndElement();
   }
   reader.ReadEndElement();
} 

[xmlclude（typeof（Deriv01））]
[xmlclude（typeof（Deriv02））]
[XmlType（“base”）]
公共抽象类基类：IXmlSerializable
{
私人国际组织；
私有字符串b；
公共INTA
{
获取{返回此。_a；}
}
公共字符串B
{
获取{返回这个。_b；}
}
受保护基类（）
{
这个。_b=string.Empty；
}
受保护基类（int a，string b）
{
这个。_a=a；
this.b=！string.IsNullOrEmpty（b）？b:string.Empty；
}
受保护的虚拟void WriteXmlAttributes（XmlWriter写入程序）
{
如果（writer==null）抛出新的ArgumentNullException（“writer”）；
WriteAttributeString（“a”，XmlConvert.ToString（this._a））；
}
受保护的虚拟void writexmlements（XmlWriter）
{
如果（writer==null）抛出新的ArgumentNullException（“writer”）；
作者。书面声明（“b”）；
编剧、编剧（本）；
writer.writeedelement（）；
}
受保护的虚拟void ReadXmlAttributes（XmlReader）
{
如果（reader==null）抛出新的ArgumentNullException（“reader”）；
INTA；
这个。_a=int.TryParse（读卡器[“a”]，输出a）？a:0；
}
受保护的虚拟void ReadXmlElements（XmlReader）
{
如果（reader==null）抛出新的ArgumentNullException（“reader”）；
reader.Read（）；
如果（！reader.IsStartElement（“b”））返回；
这是。_b=reader.ReadString（）；
reader.ReadEndElement（）；
}
#IXmlSerializable的区域实现
公共XmlSchema GetSchema（）
{
返回null；
}
公共void ReadXml（XmlReader）
{
如果（reader==null）抛出新的ArgumentNullException（“reader”）；
ReadXmlAttributes（读卡器）；
ReadXmlElements（阅读器）；
}
public void WriteXml（XmlWriter）
{
如果（writer==null）抛出新的ArgumentNullException（“writer”）；
WriteXmlAttributes（writer）；
编写要素（编写者）；
}
#端区
}
[XmlType（“deriv01”）]
公共类：基类
{
私人互联网;；
公共INTC
{
获取{返回这个。_c；}
}
公共卫生服务v01（）
{ }
公共数据源v01（整数a、字符串b、整数c）
：底座（a、b）
{
这个；
}
受保护的覆盖无效WriteXmlAttributes（XmlWriter写入程序）
{
如果（writer==null）抛出新的ArgumentNullException（“writer”）；
base.WriteXmlAttributes（编写器）；
WriteAttributeString（“c”，XmlConvert.ToString（this.\u c））；
WriteAttributeString（“xsi”，“type”，”http://www.w3.org/2001/XMLSchema-instance“，“deriv01”）；
}
受保护的覆盖无效ReadXmlAttributes（XmlReader）
{
如果（reader==null）抛出新的ArgumentNullException（“reader”）；
base.ReadXmlAttributes（reader）；
INTC；
这个._c=int.TryParse（reader[“c”]，out c）？c:0；
}
}
[XmlType（“deriv02”）]
公共类V02：基类
{
私人互联网；
公共int D
{
获取{返回此。_d；}
}
公共服务V02（）
{
}
公共数据源V02（整数a、字符串b、整数d）
：底座（a、b）
{
这个；
}
受保护的重写void writexmlements（XmlWriter）
{
如果（writer==null）抛出新的ArgumentNullException（“writer”）；
base.writexmlements（writer）；
WriteElementString（“d”，XmlConvert.ToString（this.\u d））；
}
受保护的覆盖无效ReadXmlElements（XmlReader）
{
如果（reader==null）抛出新的ArgumentNullException（“reader”）；
base.ReadXmlElements（reader）；
int d；
如果（！reader.IsStartElement（“d”））返回；
这个._d=int.TryParse（reader.ReadString（），out d）？d:0；
reader.ReadEndElement（）；
}
受保护的覆盖无效WriteXmlAttributes（XmlWriter写入程序）
{
如果（writer==null）抛出新的ArgumentNullException（“writer”）；
base.WriteXmlAttributes（编写器）；
WriteAttributeString（“xsi”，“type”，”http://www.w3.org/2001/XMLSchema-instance“，“deriv02”）；
}
}
[XmlRoot（“elementos”）]
公共类BaseClassCollection:ICollection，IXmlSerializable
{
私有列表_elementos=新列表（）；
公共基类此[int索引]
{
获取{返回此。_elementos[index]；}
}
公共BaseClassCollection（）
{ }
#ICollection的区域实现
公共无效添加（基类项）
{
如果（此元素包含（项目））返回；
本._elementos.Add（项目）；
}
公共空间清除（）
{
这是_elementos.Clear（）；
}
公共布尔包含（基类项）
{
返回此。_elementos.Contains（项目）；
}
public void CopyTo（基类[]数组，int arrayIndex）
{
这个._elementos.CopyTo（数组，数组索引）；
}
公共布尔删除（基类项）
{
返回此项。删除（项目）；
}
公共整数计数
{
获取{返回此。_elementos.Count；}
}
公共图书馆是只读的
{
获取{return false；}
}
#端区
#IEnumerable的区域实现
公共IEnumerator GetEnumerator（）
{
foreach（本节中的基类元素）