序列化之對象,字符串,byte數組,XML之間的轉換（一）

 工作一年多了，越來越感到自己不能這樣一直下去，在最好的青春里面卻已經死了。被時間消磨了意志，被工作殺死了精神。我想，我只要活着，我就要去不斷的要求自己，不斷的去追求更高的山峰。

放眼四周，有趣的靈魂越來越少。獨立的人格也越來越稀薄。我們真的不能為了工作而去工作，那樣我們活着就和死了一樣。生活充滿了重復性，我們不斷的重復着自己所做一切，上班下班，周末休息。那樣活着其實已經死了。我在這一年里面厭惡這種生活。我決定開始新的生活，制定一個計划，每天朝這個方向努力，哪怕用一年兩年甚至半輩子，我也是無怨無悔。

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using System.Xml.Serialization;

namespace Test_Control
{
    class Program
    {
        static void Main(string[] args)
        {
            Object student = new Student() { StudentID = "99", StudentName = "zhang" };

            string result = ObjectToString<Object>(student);
            Console.WriteLine(result + "\r\n");

            Student newResult = StringToObject<Student>(result);
            Console.WriteLine("ID:{0}, Name:{1}" + "\r\n", newResult.StudentID, newResult.StudentName);

            //使用UTF8編碼將字符串轉成byte數組
            var byt = SerializeHelper.ConvertToByte("12zhang3");
            // Console.WriteLine(BitConverter.ToString(byt));

            //使用UTF8編碼將byte數組轉成字符串
            string str = SerializeHelper.ConvertToString(byt);
            Console.WriteLine(str);

            //使用指定字符編碼將byte數組轉成字符串
            string strr = SerializeHelper.ConvertToString(byt, Encoding.Unicode);
            Console.WriteLine(strr);

            //將對象序列化為二進制數據 
            var obj = new Student() { StudentID = "9", StudentName = "zhang" };
            var arr = SerializeHelper.SerializeToBinary(obj);
            Console.WriteLine(BitConverter.ToString(arr));

            //將對象序列化為XML數據 並且打印
            var xml = SerializeHelper.SerializeToXml(obj);
            Console.WriteLine(BitConverter.ToString(xml));

            //將二進制數據反序列化 並且打印
            var Bt = new byte[] { 12, 12, 24 };
            Student obje = SerializeHelper.DeserializeWithBinary<Student>(arr);
            Console.WriteLine(obje.StudentName);

            Console.ReadKey();
        }

        /// <summary>
        /// 對象轉字符串（序列化后轉Base64編碼字符串）
        /// </summary>
        /// <param name="obj">對象</param>
        /// <returns>字符串</returns>
        public static string ObjectToString<T>(T obj)
        {
            using (MemoryStream stream = new MemoryStream())
            {
                IFormatter formatter = new BinaryFormatter();
                formatter.Serialize(stream, obj);
                stream.Position = 0;
                byte[] buffer = new byte[stream.Length];
                stream.Read(buffer, 0, buffer.Length);
                return Convert.ToBase64String(buffer);
            }
        }

        /// <summary>
        /// 字符串轉對象（Base64編碼字符串反序列化為對象）
        /// </summary>
        /// <param name="str">字符串</param>
        /// <returns>對象</returns>
        public static T StringToObject<T>(string str)
        {
            using (MemoryStream stream = new MemoryStream())
            {
                byte[] bytes = Convert.FromBase64String(str);
                stream.Write(bytes, 0, bytes.Length);
                stream.Position = 0;
                IFormatter formatter = new BinaryFormatter();
                return (T)formatter.Deserialize(stream);
            }
        }
    }

    /// <summary>
    /// 可序列化的類,用Serializable標示此類可序列化
    /// </summary>
    [Serializable]
    public class Student
    {
        public string StudentID { get; set; }
        public string StudentName { get; set; }
    }
    public static class SerializeHelper
    {
        /// <summary>
        /// 使用UTF8編碼將byte數組轉成字符串
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static string ConvertToString(byte[] data)
        {
            return Encoding.UTF8.GetString(data, 0, data.Length);
        }

        /// <summary>
        /// 使用指定字符編碼將byte數組轉成字符串
        /// </summary>
        /// <param name="data"></param>
        /// <param name="encoding"></param>
        /// <returns></returns>
        public static string ConvertToString(byte[] data, Encoding encoding)
        {
            return encoding.GetString(data, 0, data.Length);
        }

        /// <summary>
        /// 使用UTF8編碼將字符串轉成byte數組
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static byte[] ConvertToByte(string str)
        {
            return Encoding.UTF8.GetBytes(str);
        }

        /// <summary>
        /// 使用指定字符編碼將字符串轉成byte數組
        /// </summary>
        /// <param name="str"></param>
        /// <param name="encoding"></param>
        /// <returns></returns>
        public static byte[] ConvertToByte(string str, Encoding encoding)
        {
            return encoding.GetBytes(str);
        }

        /// <summary>
        /// 將對象序列化為二進制數據 
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static byte[] SerializeToBinary(object obj)
        {
            MemoryStream stream = new MemoryStream();
            BinaryFormatter bf = new BinaryFormatter();
            bf.Serialize(stream, obj);

            byte[] data = stream.ToArray();
            stream.Close();

            return data;
        }

        /// <summary>
        /// 將對象序列化為XML數據
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static byte[] SerializeToXml(object obj)
        {
            MemoryStream stream = new MemoryStream();
            XmlSerializer xs = new XmlSerializer(obj.GetType());
            xs.Serialize(stream, obj);

            byte[] data = stream.ToArray();
            stream.Close();

            return data;
        }

        /// <summary>
        /// 將二進制數據反序列化
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static object DeserializeWithBinary(byte[] data)
        {
            //注意，在反序列化的時候，將byte[]寫入流以后，需要將游標移到首位，即將Position置零，否則反序列化將報錯。
            MemoryStream stream = new MemoryStream();
            stream.Write(data, 0, data.Length);
            stream.Position = 0;
            BinaryFormatter bf = new BinaryFormatter();
            object obj = bf.Deserialize(stream);
            stream.Close();

            return obj;
        }

        /// <summary>
        /// 將二進制數據反序列化為指定類型對象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="data"></param>
        /// <returns></returns>
        public static T DeserializeWithBinary<T>(byte[] data)
        {
            return (T)DeserializeWithBinary(data);
        }

        /// <summary>
        /// 將XML數據反序列化為指定類型對象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="data"></param>
        /// <returns></returns>
        public static T DeserializeWithXml<T>(byte[] data)
        {
            MemoryStream stream = new MemoryStream();
            stream.Write(data, 0, data.Length);
            stream.Position = 0;
            XmlSerializer xs = new XmlSerializer(typeof(T));
            object obj = xs.Deserialize(stream);

            stream.Close();

            return (T)obj;
        }
    }
}