序列化包含多种不明类型的集合

导言:

你是否曾经想过序列化构造对象，它里面有一个集合，这个集合包含接口或者抽象类？你是否不知道所有的你要序列化的类型？好吧，如果这样，那么我可以帮助你。

使用代码：

让我们开始.首先，你将要将采用下面的帮助类，将它粘贴到你的项目之中。它将帮助你只用一行代码就能序列化一个对象为XML。

代码

/// <summary>
/// 一个用来序列化的通用类
/// </summary>
public class GenericSerializer
{
    /// <summary>
    /// Serializes the given object.
    /// </summary>
    /// <typeparam name="T">The type of the object to be serialized.</typeparam>
    /// <param name="obj">The object to be serialized.</param>
    /// <returns>String representation of the serialized object.</returns>
    public static string Serialize<T>(T obj)
    {
        XmlSerializer xs = null;
        StringWriter sw = null;
        try
        {
            xs = new XmlSerializer(typeof(T));
            sw = new StringWriter();
            xs.Serialize(sw, obj);
            sw.Flush();
            return sw.ToString();
        }
        catch (Exception ex)
        {
            throw ex;
        }
        finally
        {
            if (sw != null)
            {
                sw.Close();
                sw.Dispose();
            }
        }
    }
    public static string Serialize<T>(T obj, Type[] extraTypes)
    {
        XmlSerializer xs = null;
        StringWriter sw = null;
        try
        {
            xs = new XmlSerializer(typeof(T), extraTypes);
            sw = new StringWriter();
            xs.Serialize(sw, obj);
            sw.Flush();
            return sw.ToString();
        }
        catch (Exception ex)
        {
            throw ex;
        }
        finally
        {
            if (sw != null)
            {
                sw.Close();
                sw.Dispose();
            }
        }
    }
    /// <summary>
    /// Serializes the given object.
    /// </summary>
    /// <typeparam name="T">The type of the object to be serialized.</typeparam>
    /// <param name="obj">The object to be serialized.</param>
    /// <param name="writer">The writer to be used for output in the serialization.</param>
    public static void Serialize<T>(T obj, XmlWriter writer)
    {
        XmlSerializer xs = new XmlSerializer(typeof(T));
        xs.Serialize(writer, obj);
    }
    /// <summary>
    /// Serializes the given object.
    /// </summary>
    /// <typeparam name="T">The type of the object to be serialized.</typeparam>
    /// <param name="obj">The object to be serialized.</param>
    /// <param name="writer">The writer to be used for output in the serialization.</param>
    /// <param name="extraTypes"><c>Type</c> array
    ///       of additional object types to serialize.</param>
    public static void Serialize<T>(T obj, XmlWriter writer, Type[] extraTypes)
    {
        XmlSerializer xs = new XmlSerializer(typeof(T), extraTypes);
        xs.Serialize(writer, obj);
    }
    /// <summary>
    /// Deserializes the given object.
    /// </summary>
    /// <typeparam name="T">The type of the object to be deserialized.</typeparam>
    /// <param name="reader">The reader used to retrieve the serialized object.</param>
    /// <returns>The deserialized object of type T.</returns>
    public static T Deserialize<T>(XmlReader reader)
    {
        XmlSerializer xs = new XmlSerializer(typeof(T));
        return (T)xs.Deserialize(reader);
    }
    /// <summary>
    /// Deserializes the given object.
    /// </summary>
    /// <typeparam name="T">The type of the object to be deserialized.</typeparam>
    /// <param name="reader">The reader used to retrieve the serialized object.</param>
    /// <param name="extraTypes"><c>Type</c> array
    ///           of additional object types to deserialize.</param>
    /// <returns>The deserialized object of type T.</returns>
    public static T Deserialize<T>(XmlReader reader, Type[] extraTypes)

    {
        XmlSerializer xs = new XmlSerializer(typeof(T), extraTypes);
        return (T)xs.Deserialize(reader);
    }
    /// <summary>
    /// Deserializes the given object.
    /// </summary>
    /// <typeparam name="T">The type of the object to be deserialized.</typeparam>
    /// <param name="XML">The XML file containing the serialized object.</param>
    /// <returns>The deserialized object of type T.</returns>
    public static T Deserialize<T>(string XML)
    {
        if (XML == null || XML == string.Empty)
            return default(T);
        XmlSerializer xs = null;
        StringReader sr = null;
        try
        {
            xs = new XmlSerializer(typeof(T));
            sr = new StringReader(XML);
            return (T)xs.Deserialize(sr);
        }
        catch (Exception ex)
        {
            throw ex;
        }
        finally
        {
            if (sr != null)
            {
                sr.Close();
                sr.Dispose();
            }
        }
    }
    public static T Deserialize<T>(string XML, Type[] extraTypes)
    {
        if (XML == null || XML == string.Empty)
            return default(T);
        XmlSerializer xs = null;
        StringReader sr = null;
        try
        {
            xs = new XmlSerializer(typeof(T), extraTypes);
            sr = new StringReader(XML);
            return (T)xs.Deserialize(sr);
        }
        catch (Exception ex)
        {
            throw ex;
        }
        finally
        {
            if (sr != null)
            {
                sr.Close();
                sr.Dispose();
            }
        }
    }
    public static void SaveAs<T>(T Obj, string FileName,
                       Encoding encoding, Type[] extraTypes)
    {
        if (File.Exists(FileName))
            File.Delete(FileName);
        DirectoryInfo di = new DirectoryInfo(Path.GetDirectoryName(FileName));
        if (!di.Exists)
            di.Create();
        XmlDocument document = new XmlDocument();
        XmlWriterSettings wSettings = new XmlWriterSettings();
        wSettings.Indent = true;
        wSettings.Encoding = encoding;
        wSettings.CloseOutput = true;
        wSettings.CheckCharacters = false;
        using (XmlWriter writer = XmlWriter.Create(FileName, wSettings))
        {
            if (extraTypes != null)
                Serialize<T>(Obj, writer, extraTypes);
            else
                Serialize<T>(Obj, writer);
            writer.Flush();
            document.Save(writer);
        }
    }
    public static void SaveAs<T>(T Obj, string FileName, Type[] extraTypes)
    {
        SaveAs<T>(Obj, FileName, Encoding.UTF8, extraTypes);
    }
    public static void SaveAs<T>(T Obj, string FileName, Encoding encoding)
    {
        SaveAs<T>(Obj, FileName, encoding, null);
    }
    public static void SaveAs<T>(T Obj, string FileName)
    {
        SaveAs<T>(Obj, FileName, Encoding.UTF8);
    }
    public static T Open<T>(string FileName, Type[] extraTypes)
    {
        T obj = default(T);
        if (File.Exists(FileName))
        {
            XmlReaderSettings rSettings = new XmlReaderSettings();
            rSettings.CloseInput = true;
            rSettings.CheckCharacters = false;
            using (XmlReader reader = XmlReader.Create(FileName, rSettings))
            {
                reader.ReadOuterXml();
                if (extraTypes != null)
                    obj = Deserialize<T>(reader, extraTypes);
                else
                    obj = Deserialize<T>(reader);
            }
        }
        return obj;
    }
    public static T Open<T>(string FileName)
    {
        return Open<T>(FileName, null);
    }
}

现在我们已经了解这个方法了，让我们看看我们的问题所在。举一个例子，我们有一个抽象类，Animal。然后有两个继承Animal的类：Human和Dog。

代码

public abstract class Animal
{
    public abstract int Legs
    {
        get;
        set;
    }

    public abstract bool HasTail
    {
        get;
        set;
    }
}

public class Human : Animal
{

    public Human()
    {
        this.Legs = 2;
        this.HasTail = false;
    }

    public override int Legs
    {
        get;
        set;
    }

    public override bool HasTail
    {
        get;
        set;
    }

}

public class Dog : Animal
{

    public Dog()
    {
        this.Legs = 4;
        this.HasTail = true;
        this.Breed = "Black Lab";
    }

    public override int Legs
    {
        get;
        set;
    }

    public override bool HasTail
    {
        get;
        set;
    }

    public string Breed
    {
        get;
        set;
    }
}

现在我们有一个想要序列化的对象。它是HouseHold，它的有一个Animal集合属性：

public class HouseHold
{
    public HouseHold()
    {
        this.Residents = new List<Animal>();
    }

    public List<Animal> Residents
    {
        get;
        set;
    }
}

现在，我们序列化这个对象。

代码

try
{
    HouseHold hh = new HouseHold();
    hh.Residents.Add(new Human());
    hh.Residents.Add(new Human());
    hh.Residents.Add(new Dog());

    string xml = GenericSerializer.Serialize<HouseHold>(hh);
    Console.WriteLine(xml);
}
catch (Exception ex)
{
    Console.WriteLine(ex.ToString());
}

Console.Read();

我们将会得到下面的Exception的Message：

"生成 XML 文档时出错。

下面是 InnerException的Message ：

"不应是类型 Kirin.Human。使用 XmlInclude 或 SoapInclude 属性静态指定非已知的类型。"

这里有个关键字“静态”，我们可以在每个类的顶部放置XmlInclude属性解决这个问题，如：

代码

   [XmlInclude(typeof(Animal)), XmlInclude(typeof(Human))]
    public class HouseHold
    {
        public HouseHold()
        {
            this.Residents = new List<Animal>();
        }

        public List<Animal> Residents
        {
            get;
            set;
        }
    }

但如果我们不知道的继承Animal的所有类，如果我们的应用是可延展的，需要能够使用由用户自定义类型，上面的代码是解决不了问题的。让我们向下看，我会告诉你如何可以做到的。

首先，我们要做的是使HouseHold类实现IXmlSerializable接口，这样我们就可以拦截这个对象的序列化，我们自己去序列它。

接着，我们构建一个方法，能检查所有的类型，在这个例子中，我们使用反射去查询的所有继承了Animal类的程序集。

代码

public class HouseHold : IXmlSerializable
{
    private static Type[] _animalTypes;

    static HouseHold()
    {
        _animalTypes = GetAnimalTypes().ToArray();
    }

    public HouseHold()
    {
        this.Residents = new List<Animal>();
    }

    public List<Animal> Residents
    {
        get;
        set;
    }

    #region IXmlSerializable Members

    public System.Xml.Schema.XmlSchema GetSchema()
    {
        return null;
    }

    public void ReadXml(System.Xml.XmlReader reader)
    {
        bool wasEmpty = reader.IsEmptyElement;
        reader.Read();
        if (wasEmpty)
            return;

        reader.MoveToContent();
        reader.ReadStartElement("Residents");
        this.Residents = GenericSerializer.Deserialize<List<Animal>>(reader, _animalTypes);
        reader.ReadEndElement();

        //Read Closing Element
        reader.ReadEndElement();
    }

    public void WriteXml(System.Xml.XmlWriter writer)
    {
        writer.WriteStartElement("Residents");
        GenericSerializer.Serialize<List<Animal>>(this.Residents, writer, _animalTypes);
        writer.WriteEndElement();
    }

    #endregion

    public static List<Type> GetAnimalTypes()
    {

        List<Type> types = new List<Type>();

        Assembly asm = typeof(HouseHold).Assembly;

        Type tAnimal = typeof(Animal);

        //Query our types. We could also load any other assemblies and
        //query them for any types that inherit from Animal

        foreach (Type currType in asm.GetTypes())
        {
        if (!currType.IsAbstract
            && !currType.IsInterface
            && tAnimal.IsAssignableFrom(currType))
            types.Add(currType);
        }

        return types;
    }
}

现在，我们运行我们的测试代码，能顺利通过。希望对你有所帮助，谢谢！

（全文完）

以下为广告部分