任意泛型序列化SerializableHelper

话不多说，直接上代码

 

 public class SerializableHelper
    {
        /// <summary>
        /// 序列化成一个字节数组
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static byte[] SerializeToBytes<T>(T t)
        {
            MemoryStream mStream = new MemoryStream();
            BinaryFormatter ser = new BinaryFormatter();
            ser.Serialize(mStream, t);
            return mStream.ToArray();
        }

        /// <summary>
        /// 序列化成一个字符串
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns>序列化代码</returns>
        public static string SerializeToXml<T>(T t)
        {
            try
            {
                XmlSerializer s = new XmlSerializer(typeof(T));
                Stream stream = new MemoryStream();
                s.Serialize(stream, t);

                stream.Seek(0, SeekOrigin.Begin); //这一点非常重要 否则无法读取
                string strSource = "";
                using (StreamReader reader = new StreamReader(stream))
                {
                    strSource = reader.ReadToEnd();
                }
                return strSource;
            }
            catch { return null; }

        }
        /// <summary>
        /// xml 文件反序列化为泛型数组
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="path"></param>
        /// <returns></returns>
        public static T DeSerialize<T>(FileInfo fi)
        {
            if (fi.Exists == false) return default(T);

            XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));

            FileStream fs = fi.OpenRead();
            T t;
            try
            {
                t = (T)xmlSerializer.Deserialize(fs);
            }
            finally
            {
                fs.Close();
            }
            return t;
        }
        /// <summary>
        /// 字符串反序列化成一个类
        /// </summary>
        /// <param name="binary"></param>
        /// <returns></returns>
        public static T DeSerialize<T>(string xmlSource)
        {
            if (string.IsNullOrEmpty(xmlSource)) return default(T);

            try
            {
                XmlSerializer x = new XmlSerializer(typeof(T));

                Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(xmlSource));
                stream.Seek(0, SeekOrigin.Begin);
                object obj = x.Deserialize(stream);
                stream.Close();

                return (T)obj;
            }
            catch
            {
                return default(T);
            }
        }
        public static Dictionary<TKey, TValue> DeSerialize<TKey, TValue>(FileInfo fi)
        {
            if (fi.Exists == false) return default(Dictionary<TKey, TValue>);

            FileStream fs = fi.OpenRead();
            if (fs.Length == 0) return default(Dictionary<TKey, TValue>);

            XmlReader reader = XmlReader.Create(fs);
            XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
            XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
            bool wasEmpty = reader.IsEmptyElement;

            if (wasEmpty)
                return default(Dictionary<TKey, TValue>);

            Dictionary<TKey, TValue> dic = new Dictionary<TKey, TValue>();
            while (reader.Read())
            {
                if (reader.NodeType != XmlNodeType.Element) continue;
                if (reader.Name == "Root") continue;

                reader.ReadStartElement("Row");
                reader.ReadStartElement("Key");
                TKey key = (TKey)keySerializer.Deserialize(reader);
                reader.ReadEndElement();
                reader.ReadStartElement("Value");
                TValue value = (TValue)valueSerializer.Deserialize(reader);
                reader.ReadEndElement();
                dic.Add(key, value);
                reader.ReadEndElement();
                //reader.MoveToContent();

            }
            return dic;
        }

        /// <summary>
        /// 序列化泛型数组为xml文件
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <param name="FullName"></param>
        /// <returns>是否序列化成功</returns>
        public static bool Serialize<T>(T t, string FullName)
        {
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(T));
            TextWriter writer = new StreamWriter(FullName);
            try
            {
                xmlSerializer.Serialize(writer, t);

                return true;
            }
            catch
            {
                return false;
            }
            finally
            {
                writer.Close();
            }
        }
        /// <summary>
        /// 序列化 Dictionary
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <typeparam name="TValue"></typeparam>
        /// <param name="dic"></param>
        /// <param name="FullName"></param>
        /// <returns></returns>
        public static bool Serialize<TKey, TValue>(Dictionary<TKey, TValue> dic, string FullName)
        {
            try
            {
                System.Xml.XmlWriterSettings settings = new System.Xml.XmlWriterSettings();
                settings.Encoding = Encoding.UTF8;
                settings.Indent = true;
                settings.ConformanceLevel = ConformanceLevel.Fragment;

                XmlWriter writer = XmlWriter.Create(FullName, settings);

                XmlSerializer KeySerializer = new XmlSerializer(typeof(TKey));
                XmlSerializer ValueSerializer = new XmlSerializer(typeof(TValue));

                writer.WriteStartElement("Root");
                foreach (KeyValuePair<TKey, TValue> kv in dic)
                {
                    writer.WriteStartElement("Row");
                    writer.WriteStartElement("Key");
                    KeySerializer.Serialize(writer, kv.Key);
                    writer.WriteEndElement();
                    writer.WriteStartElement("Value");
                    ValueSerializer.Serialize(writer, kv.Value);
                    writer.WriteEndElement();
                    writer.WriteEndElement();

                } writer.WriteEndElement();
                writer.Close();

                return true;
            }
            catch
            {
                try
                {
                    File.Delete(FullName);
                }
                catch { }
                return false;
            }
        }

        /// <summary>
        /// 序列化DataTable
        /// </summary>
        /// <param name="pDt">包含数据的DataTable</param>
        /// <returns>序列化的DataTable</returns>
        public static string SerializeDataTableXml(DataTable pDt)
        {
            // 序列化DataTable
            StringBuilder sb = new StringBuilder();
            XmlWriter writer = XmlWriter.Create(sb);
            XmlSerializer serializer = new XmlSerializer(typeof(DataTable));
            serializer.Serialize(writer, pDt);
            writer.Close();
            return sb.ToString();
        }

        /// <summary>
        /// 反序列化DataTable
        /// </summary>
        /// <param name="pXml">序列化的DataTable</param>
        /// <returns>DataTable</returns>
        public static DataTable DeserializeDataTable(string pXml)
        {

            StringReader strReader = new StringReader(pXml);
            XmlReader xmlReader = XmlReader.Create(strReader);
            XmlSerializer serializer = new XmlSerializer(typeof(DataTable));

            DataTable dt = serializer.Deserialize(xmlReader) as DataTable;

            return dt;
        }

    }