C#系列化方法整理

常用的几个序列化反序列化类

• BinaryFormatter
• XmlSerializer
• JavaScriptSerializer
• DataContractDeserialize

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Web.Script.Serialization;
using System.Xml.Serialization;

namespace Test2020._5
{
    public class Serializable{
        /// <summary>
        /// 序列化法1：BinaryFormatter类
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        public static void BinarySerialize<T>(T entity)
        {
            FileStream fs = new FileStream(@"F:\Read4.txt", FileMode.Create);
            BinaryFormatter bf = new BinaryFormatter();
            bf.Serialize(fs, entity);
            fs.Close();
        }

        /// <summary>
        /// 反序列化法1：BinaryFormatter类
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        public static T BinaryDeserialize<T>()
        {
            FileStream fs = new FileStream(@"F:\Read4.txt", FileMode.Open);
            BinaryFormatter bf2 = new BinaryFormatter();
            T entity = (T)bf2.Deserialize(fs);
            fs.Close();
            return entity;
        }

        /// <summary>
        ///  序列化法2：XmlSerializer 类
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        private static T XmlDeserialize<T>()
        {
            FileStream fs = new FileStream(@"F:\Read1.txt", FileMode.Open);
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(Person));
            T entity = (T)xmlSerializer.Deserialize(fs);
            fs.Close();
            return entity;
        }

        /// <summary>
        ///  反序列化法2：XmlSerializer 类
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        private static void XmlSerializer<T>(T entity)
        {
            FileStream fs = new FileStream(@"F:\Read1.txt", FileMode.Create);
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(Person));
            xmlSerializer.Serialize(fs, entity);
            fs.Close();
        }


        /// <summary>
        /// 序列化法3
        /// </summary>
        /// <typeparam name="T">序列化的对象</typeparam>
        /// <param name="person"></param>
        /// <returns></returns>
        private static string ScriptSerialize<T>(T person)
        {
            JavaScriptSerializer serializer = new JavaScriptSerializer();
            return serializer.Serialize(person);
        }

        /// <summary>
        /// 反序列化法3
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="strJson"></param>
        /// <returns></returns>
        public static T ScriptDeserialize<T>(string strJson)
        {
            JavaScriptSerializer js = new JavaScriptSerializer();
            return js.Deserialize<T>(strJson);
        }


        /// <summary>
        /// 序列化法4：DataContractJsonSerializer
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="person"></param>
        /// <returns></returns>
        private static string DataContractSerializer<T>(T person)
        {
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(T));
            string str = "";
            using (MemoryStream stream = new MemoryStream())
            {
                serializer.WriteObject(stream, person);
                str = System.Text.Encoding.UTF8.GetString(stream.ToArray());
            }
            return str;
        }


        /// <summary>
        /// 反序列化法4：DataContractJsonSerializer
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="jsonStr"></param>
        /// <returns></returns>
        private static T DataContractDeserialize<T>(string jsonStr)
        {
            T entity;
            DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(Person));
            using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(jsonStr)))
            {
                entity = (T)jsonSerializer.ReadObject(stream);
            }
            return entity;
        }
    }


    [Serializable]
    //如果要想保存某个class中的字段,必须在class前面加个这样attribute(C#里面用中括号括起来的标志符)
    public class Person
    {
        public int age;
        public string name;
        [NonSerialized] //如果某个字段不想被保存,则加个这样的标志
        public string secret;
    }

}