XmlSerializer：“在此上下文中不能使用类型‘Type’”

我试图找出如何使用序列化任何类Xml序列化器，不使用Xml包含属性。通常可以工作，但使用以下代码时出现异常：

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Xml.Serialization;

namespace Test
{
    public class ReactObject { }

    public class ReactListObject : ReactObject { }

    public class ReactList<T> : ReactObject, ICollection, IList<T>
    {
        public ReactList() { }

        public virtual void AddRange(IEnumerable<T> values) { }

        [XmlArray(ElementName = "Items", IsNullable = false)]
        public T[] Items
        {
            get { lock (SyncRoot) { return (ItemsList.ToArray()); } }
            set { lock (SyncRoot) { ItemsList = new List<T>(value); } }
        }

        protected List<T> ItemsList = new List<T>();

        public bool IsSynchronized { get { return (true); } }
        public object SyncRoot { get { return (mRootObject); } }

        private object mRootObject = new object();

        public void CopyTo(Array array, int index) { CopyTo(array, index); }

        [XmlIgnore()]
        public T this[int index] {
            get { return (ItemsList[index]); }
            set { ItemsList[index] = value; }
        }

        public int IndexOf(T item) { return (ItemsList.IndexOf(item)); }

        public virtual void Insert(int index, T item) { }

        public virtual void RemoveAt(int index) { }

        public int Count { get { lock (SyncRoot) { return (ItemsList.Count); } } }

        public bool IsReadOnly { get { return (false); } }

        public virtual void Add(T item) { ItemsList.Add(item); }

        public void Clear() { }

        public bool Contains(T item) { return (false); }

        public virtual void CopyTo(T[] array, int arrayIndex) { }

        public virtual bool Remove(T item) { return (false); }

        public IEnumerator<T> GetEnumerator() { return (ItemsList.GetEnumerator()); }

        IEnumerator IEnumerable.GetEnumerator() { return (ItemsList.GetEnumerator()); }
    }

    [XmlInclude(typeof(B))]
    public class A : ReactListObject
    {
        public int AValue = 1;
    }

    public class B : A
    {
        public int BValue = 2;
    }

    public class AList : ReactList<A>
    {

    }

    static class Program
    {
        [STAThread]
        static void Main()
        {
            // NOT good serializer for the type AList
            XmlSerializer ser1 = new XmlSerializer(typeof(ReactObject), new Type[] { typeof(A), typeof(B), typeof(ReactList<A>), typeof(AList) });
            // Good serializer for the type AList
            XmlSerializer ser2 = new XmlSerializer(typeof(ReactList<A>), new Type[] { typeof(A), typeof(B), typeof(AList) });
            AList list = new AList();

            list.Add(new A());
            list.Add(new B());

            using (FileStream mStream = new FileStream("C:\\Test.xml", FileMode.Create)) {
                ser2.Serialize(mStream, list);
            }
            using (FileStream mStream = new FileStream("C:\\Test.xml", FileMode.Create)) {
                ser1.Serialize(mStream, list);
            }
        }
    }
}

抛出的异常是

类型 Test.AList 不能在此上下文中使用

这是类图，以帮助阅读代码

我想花更多的时间来描述我想要实现的目标：我想最大限度地减少 XML 序列化器实例的创建（实际上，序列化的每种类型都有自己的序列化器；应用程序每次都会重新创建唯一存在的序列化器）未包含的类型应被序列化。(*)

看来，恕我直言，

• 可以序列化任何反应对象（和派生类型）与类型的序列化器反应对象，直到在派生层次结构中引入泛型类。序列化器的额外类型应涵盖所有预期类型。
• 在这种情况下，类型派生自泛型类基于反应对象，该类型无法使用类型的序列化器序列化反应对象，但具有通用类型的序列化器。

这可能是一个问题，因为当我需要反序列化它时，我必须知道序列化对象的类型。相反，反序列化“非泛型”反应对象type 足以使用 type 的通用序列化器反应对象，而不知道序列化对象的确切类型。

(*) 实际上我不知道这个目标会带来明显的改进。核心问题是“对于所有（包含的）类型使用单个序列化程序集更好，还是对于每种类型使用序列化程序集更好？"

Does ReactListObject继承自ReactObject? ser1被实例化以序列化类型ReactObject，但从你的代码示例我只能看出list属于类型ReactListObject.