生成 XML 文档时出错。使用 XmlInclude 或 SoapInclude 特性静态指定非已知的类型。

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Serialization;

namespace ConsoleApp6
{
    class Program
    {
        static void Main(string[] args)
        {
            string r = string.Empty;
            List<Base> list = new List<Base>() {
                new A() { Name = "initName", AName = "aa" },
                new B() { Name = "initName", BName = "bb" }
            };
            try
            {
                r = XmlHelper.SerializeToXml(list);
            }
            catch (Exception ex)
            {
                /* 生成 XML 文档时出错。 */
                Console.WriteLine(ex.Message);
                /* 不应是类型 ConsoleApp6.A。使用 XmlInclude 或 SoapInclude 特性静态指定非已知的类型。 */
                Console.WriteLine(ex.InnerException.Message);
            }

            Console.WriteLine(r);
            Console.Read();
        }
    }

    #region [ Test Class ]
    //处理方法：在基类上加上所有需要序列化的子类的 XmlInclude 特性就可以了。
    //下面的代码去掉注释，即可正常运行
    /*
    [XmlInclude(typeof(A))]
    [XmlInclude(typeof(B))]
    */
    public class Base
    {
        public string Name { get; set; }
    }

    public class A : Base
    {
        public string AName { get; set; }
    }

    public class B : Base
    {
        public string BName { get; set; }
    }
    #endregion

    #region [ XMLHelper ]
    public static class XmlHelper
    {
        public static void ObjectWriteToXmlFile<T>(T myObject, string filePath)
        {
            string xmlString = SerializeToXml<T>(myObject);
            File.WriteAllText(filePath, xmlString);
        }

        public static T XmlFileToObject<T>(string filePath)
        {
            string xmlString = File.ReadAllText(filePath);
            return DeserializeToObject<T>(xmlString);
        }

        /// <summary>
        /// 将自定义对象序列化为XML字符串
        /// </summary>
        /// <param name="myObject">自定义对象实体</param>
        /// <returns>序列化后的XML字符串</returns>
        public static string SerializeToXml<T>(T myObject)
        {
            if (myObject != null)
            {
                XmlSerializer xs = new XmlSerializer(typeof(T));

                MemoryStream stream = new MemoryStream();
                XmlTextWriter writer = new XmlTextWriter(stream, Encoding.UTF8);
                writer.Formatting = Formatting.None;//缩进
                xs.Serialize(writer, myObject);

                stream.Position = 0;
                StringBuilder sb = new StringBuilder();
                using (StreamReader reader = new StreamReader(stream, Encoding.UTF8))
                {
                    string line;
                    while ((line = reader.ReadLine()) != null)
                    {
                        sb.Append(line);
                    }
                    reader.Close();
                }
                writer.Close();
                return sb.ToString();
            }
            return string.Empty;
        }

        /// <summary>
        /// 将XML字符串反序列化为对象
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="xml">XML字符</param>
        /// <returns></returns>
        public static T DeserializeToObject<T>(string xml)
        {
            T myObject;
            XmlSerializer serializer = new XmlSerializer(typeof(T));
            StringReader reader = new StringReader(xml);
            myObject = (T)serializer.Deserialize(reader);
            reader.Close();
            return myObject;
        }
    }
    #endregion
}