C#——序列化和反序列化

 

    public class SerializationHelper
    {
        /// <summary>
        /// 将可序列化的对象序列化成字节数组
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static byte[] ObjectToByteArray(object obj)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                BinaryFormatter bf = new BinaryFormatter();
                bf.Serialize(ms, obj);
                return ms.ToArray();
            }
        }

        /// <summary>
        /// 将已经序列化成的字节数组反序列化到object
        /// </summary>
        /// <param name="bArr"></param>
        /// <returns></returns>
        public static object ByteArrayToObject(byte[] bArr)
        {
            using (MemoryStream ms = new MemoryStream(bArr, 0, bArr.Length))
            {
                BinaryFormatter bf = new BinaryFormatter();
                return bf.Deserialize(ms);
            }
        }

        /// <summary>
        /// 将指定的对象序列化到流中
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <param name="stream"></param>
        public static void Serialize<T>(T obj, Stream stream)
        {
            if (stream == null)
            {
                return;
            }
            BinaryFormatter bf = new BinaryFormatter();
            bf.Serialize(stream, obj);
        }

        /// <summary>
        /// 将已序列化成的流发序列化成原对象T
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="stream"></param>
        /// <returns></returns>
        public static T DeSerialize<T>(Stream stream)
        {
            if (stream == null)
            {
                return default(T);
            }
            BinaryFormatter bf = new BinaryFormatter();
            return (T)bf.Deserialize(stream);
        }

        /// <summary>
        /// 将指定的对象序列化到文件中，path应包含文件名，如果
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <param name="path"></param>
        public static void Serialize<T>(T obj, string path)
        {
            using (FileStream fs = new FileStream(path, FileMode.Create))
            {
                BinaryFormatter bf = new BinaryFormatter();
                bf.Serialize(fs, obj);
            }
        }

        /// <summary>
        /// 从指定的文件反序列化到原对象T
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="path"></param>
        /// <returns></returns>
        public static T DeSerialize<T>(string path)
        {
            FileInfo fi = new FileInfo(path);
            if (!fi.Exists)
            {
                return default(T);
            }
            using (FileStream fs = new FileStream(path, FileMode.Open))
            {
                BinaryFormatter bf = new BinaryFormatter();
                return (T)bf.Deserialize(fs);
            }
        }


        /// <summary>
        /// 将指定的对象序列化成XML文件
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <param name="path"></param>
        public static void SerializeToXml<T>(T obj, string path)
        {
            XmlSerializer xs = new XmlSerializer(obj.GetType());
            using (TextWriter writer = new StreamWriter(path, false))
            {
                xs.Serialize(writer, obj);
            }
        }

        /// <summary>
        /// 从指定的XML文件反序列话到对象T
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="path"></param>
        /// <returns></returns>
        public static T DeserializeFromXml<T>(string path)
        {
            XmlSerializer xs = new XmlSerializer(typeof(T));
            using (TextReader reader = new StreamReader(path))
            {
                return (T)xs.Deserialize(reader);
            }
        }


        /// <summary>
        /// 将指定的对象序列化成XML流
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <param name="stream"></param>
        public static void SerializeToXml<T>(T obj, Stream stream)
        {
            if (stream == null)
            {
                return;
            }
            var xmlSerializer = new XmlSerializer(obj.GetType());
            xmlSerializer.Serialize(stream, obj);
        }


        /// <summary>
        /// 从指定的XML流里反序列话成原对象T
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="stream"></param>
        /// <returns></returns>
        public static T DeserializeFromXml<T>(Stream stream)
        {
            if (stream == null)
            {
                return default(T);
            }
            XmlSerializer xs = new XmlSerializer(typeof(T));
            return (T)xs.Deserialize(stream);
        }


        /// <summary>
        /// 将对象序列化成Json
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static string JsonSerialize<T>(T t)
        {
            var ser = new DataContractJsonSerializer(typeof(T));
            using (var stream = new MemoryStream())
            {
                ser.WriteObject(stream, t);
                return Encoding.UTF8.GetString(stream.ToArray());
            }
        }

        /// <summary>
        /// 将List<T>序列化成Json
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="list"></param>
        /// <returns></returns>
        public static string JsonSerialize<T>(IEnumerable<T> list)
        {
            string result = "[{0}]";
            StringBuilder sb = new StringBuilder();
            foreach (var o in list)
            {
                sb.Append(JsonSerialize<T>(o)).Append(",");
            }
            return string.Format(result, sb.ToString().TrimEnd(','));
        }

        /// <summary>
        /// 将Json反序列化成对象T
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="jsonString"></param>
        /// <returns></returns>
        public static T JsonDeserialize<T>(string jsonString)
        {
            var ser = new DataContractJsonSerializer(typeof(T));
            byte[] buffer = Encoding.UTF8.GetBytes(jsonString);
            using (var stream = new MemoryStream(buffer) { Position = 0 })
            {
                return (T)ser.ReadObject(stream);
            }
        }
    }