从discuz 里扒过来的一个通用序列化和反序列化类

感觉蛮好用的。我将一些常用的实体类型序列化成xml格式保存成xml，在系统运行时，先将其读取到缓存。

using System;
using System.Collections.Generic;
using System.Text;
using System.Xml.Serialization;
using System.IO;
using System.Xml;

namespace HMYY.Common
{
    public class SerializationHelper
    {

        /* 字典，用来存储XmlSerializer 

       * 注意是此处是static 

       * 实际上起缓存的作用 

       */
        private static Dictionary<int, XmlSerializer> serializer_dict = new Dictionary<int, XmlSerializer>();

        /// <summary> 

        /// 为给予的类匹配一个XmlSerializer 对象， 

        /// 若之前就使用过，则从缓存里调出来，若没有， 

        /// 则新建一个对应的XmlSerializer 对象。 

        /// </summary> 

        /// <param name="t">给予的类</param> 

        /// <returns></returns> 
        public static XmlSerializer GetSerializer(Type t)
        {
            //先获得type 的哈希值，作为字典的索引 
            int type_hash = t.GetHashCode();
            //如果字典里没有这个type的哈希，就创建一个，放到字典表里 

            if (!serializer_dict.ContainsKey(type_hash))

                serializer_dict.Add(type_hash, new XmlSerializer(t));

            //查询到这个哈希对应的对象，传出去 
            return serializer_dict[type_hash];
        }

        /// <summary>
        /// 反序列化
        /// </summary>
        /// <param name="type">对象类型</param>
        /// <param name="filepath">文件路径</param>
        /// <returns></returns>
        public static object Load(Type type, string filepath)
        {
            FileStream fs = null;
            try
            {
                fs = new FileStream(filepath, FileMode.Open, FileAccess.Read, FileShare.Read);
                XmlSerializer serializer = new XmlSerializer(type);
                return serializer.Deserialize(fs);
            }
            catch(Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (fs != null)
                {
                    fs.Close();
                    fs.Dispose();
                }
            }


        }

        /// <summary>
        /// 序列化
        /// </summary>
        /// <param name="obj">对象</param>
        /// <param name="filename">文件路径</param>
        public static bool Save(object obj, string filepath)
        {
            bool Isok = false;
            FileStream fs = null;
            try
            {
                fs = new FileStream(filepath, FileMode.Create, FileAccess.Write);
                XmlSerializer serializer = new XmlSerializer(obj.GetType());
                serializer.Serialize(fs, obj);
                Isok = true;
            }
            catch(Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (fs != null)
                {
                    fs.Close();
                    fs.Dispose();
                }
            }

            return Isok;
        }


        /// <summary> 

        /// xml序列化成字符串 

        /// </summary> 

        /// <param name="obj">对象</param> 

        /// <returns>xml字符串</returns> 

        public static string Serialize(object obj)
        {

            string returnStr = "";

            XmlSerializer serializer = GetSerializer(obj.GetType());

            // 实例化一个内存流 

            MemoryStream ms = new MemoryStream();

            XmlTextWriter xtw = null;

            StreamReader sr = null;

            try
            {

                //实例化一个xml的写对象,其中使用utf-8 编码,写入到刚实例化的内存流中去 

                xtw = new System.Xml.XmlTextWriter(ms, Encoding.UTF8);

                //设置缩进方式 

                xtw.Formatting = System.Xml.Formatting.Indented;



                //序列化它 

                serializer.Serialize(xtw, obj);

                /* 

                 * 此时内存流已经指向写完的地方, 

                 * 要再次读取到这个内存里的内容, 

                 * 需要将其"指针"指向内存流的开始 

                 * 下面一句就是做这个事情 

                 * param1  针对param2 的偏移量, 

                 * param2  内存开始的地方 

                 */

                ms.Seek(0, SeekOrigin.Begin);

                //实例化一个流阅读器,去读内存流 

                sr = new StreamReader(ms);

                returnStr = sr.ReadToEnd();

            }

            catch (Exception ex)
            {

                throw ex;

            }

            finally
            {

                if (xtw != null)

                    xtw.Close();

                if (sr != null)

                    sr.Close();

                ms.Close();

            }

            return returnStr;



        }



        /// <summary> 

        /// 反序列化 ,通过一个string 

        /// </summary> 

        /// <param name="type">反序列化的类的类型</param> 

        /// <param name="s">序列源</param> 

        /// <returns></returns> 

        public static object DeSerialize(Type type, string s)
        {

            /* 

             * 此处将字符串转化为byte数组 

             * 其中值得注意的是,使用UTF-8 编码 

             * 就可以回避因为是非ASCII码被解析成乱码了 

             */

            byte[] b = System.Text.Encoding.UTF8.GetBytes(s);

            try
            {

                XmlSerializer serializer = GetSerializer(type);

                return serializer.Deserialize(new MemoryStream(b));

            }

            catch (Exception ex)
            {

                throw ex;

            }

        } 




    }
}