C#序列化與反序列化學習筆記-有解無憂

本筆記摘抄自：https://www.cnblogs.com/maitian-lf/p/3670570.html，記錄一下學習程序以備后續查用，

序列化是把一個記憶體中的物件的資訊轉化成一個可以持久化保存的形式，以便于保存或傳輸，序列化的主要作用是不同平臺之間進行通信，常用的序

列化有json、xml、檔案等，下面就逐個講下這三種序列化的方法，

一、序列化為json

C#中用于物件和json相互轉換的原生類有兩個：DataContractJsonSerializer和JavaScriptSerializer，其中JavaScriptSerializer主要用于web瀏覽器和服

務器之間的通信，這里主要講DataContractJsonSerializer的使用，要使用DataContractJsonSerializer，先要在專案中參考System.Runtime.Serialization，

首先準備一個測驗的類Book：

    class Program
    {
        /// <summary>
        /// Book類
        /// </summary>
        [DataContract]
        class Book
        {
            [DataMember]
            public int ID { get; set; }

            [DataMember]
            public string Name { get; set; }

            [DataMember]
            public float Price { get; set; }
        }

        static void Main(string[] args)
        {
        }
    }

View Code

[DataContract]指定該型別要定義或實作一個資料協定，并可由序列化程式（如System.Runtime.Serialization.DataContractSerializer）進行序列化，

[DataMember]當應用于型別的成員時，指定該成員是資料協定的一部分并可由System.Runtime.Serialization.DataContractSerializer進行序列化，

首先創建一個Book物件，然后實體化一個DataContractJsonSerializer實體，最后用該實體的WriteObject()方法將物件寫到流中，代碼如下：

    class Program
    {
        /// <summary>
        /// Book類
        /// </summary>
        [DataContract]
        class Book
        {
            [DataMember]
            public int Id { get; set; }

            [DataMember]
            public string Name { get; set; }

            [DataMember]
            public float Price { get; set; }
        }

        static void Main(string[] args)
        {
            #region 物件序列化為json
            Book book = new Book() { Id = 101, Name = "C#程式設計", Price = 79.5f };

            //序列化為json
            DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(Book));
            using (MemoryStream stream = new MemoryStream())
            {
                jsonSerializer.WriteObject(stream, book);
                string result = Encoding.UTF8.GetString(stream.ToArray());
                Console.WriteLine(result);
            }
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

將一個json格式的字串反序列化為物件是用DataContractJsonSerializer實體的ReadObject()方法，代碼如下：

    class Program
    {
        /// <summary>
        /// Book類
        /// </summary>
        [DataContract]
        class Book
        {
            [DataMember]
            public int Id { get; set; }

            [DataMember]
            public string Name { get; set; }

            [DataMember]
            public float Price { get; set; }
        }

        static void Main(string[] args)
        {
            #region json反序列化為物件
            Book book = new Book();
            //json反序列化為物件
            string oriStr = "{\"Id\":101,\"Name\":\"C#程式設計\",\"Price\":79.5}";
            DataContractJsonSerializer jsonSerializer = new DataContractJsonSerializer(typeof(Book));
            using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(oriStr)))
            {
                Book outBook = jsonSerializer.ReadObject(stream) as Book;
                Console.WriteLine($"{outBook.Id} {outBook.Name} {outBook.Price}");
            }
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

我們也可以把上面的json序列化與反序列為封裝成泛型方法，這樣可以公用，全部代碼如下：

    class Program
    {
        /// <summary>
        /// Book類
        /// </summary>
        [DataContract]
        class Book
        {
            [DataMember]
            public int Id { get; set; }

            [DataMember]
            public string Name { get; set; }

            [DataMember]
            public float Price { get; set; }
        }

        public class SerializerHelper
        {
            /// 將物件序列化為json檔案
            /// </summary>
            /// <typeparam name="T">型別</typeparam>
            /// <param name="t">實體</param>
            /// <param name="path">存放路徑</param>
            public static void ObjectToJson<T>(T t, string path) where T : class
            {
                DataContractJsonSerializer formatter = new DataContractJsonSerializer(typeof(T));
                using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate))
                {
                    formatter.WriteObject(stream, t);
                }
            }

            /// <summary>
            /// 將物件序列化為json字串
            /// </summary>
            /// <typeparam name="T">型別</typeparam>
            /// <param name="t">實體</param>
            /// <returns>json字串</returns>
            public static string ObjectToJson<T>(T t) where T : class
            {
                DataContractJsonSerializer formatter = new DataContractJsonSerializer(typeof(T));
                using (MemoryStream stream = new MemoryStream())
                {
                    formatter.WriteObject(stream, t);
                    string result = Encoding.UTF8.GetString(stream.ToArray());
                    return result;
                }
            }

            /// <summary>
            /// 將json字串反序列化為物件
            /// </summary>
            /// <typeparam name="T">型別</typeparam>
            /// <param name="json">json格式字串</param>
            /// <returns>物件</returns>
            public static T JsonToObject<T>(string json) where T : class
            {
                DataContractJsonSerializer formatter = new DataContractJsonSerializer(typeof(T));
                using (MemoryStream stream = new MemoryStream(Encoding.UTF8.GetBytes(json)))
                {
                    T result = formatter.ReadObject(stream) as T;
                    return result;
                }
            }
        }

        static void Main(string[] args)
        {
            #region json序列化與反序列化泛型方法
            Book book = new Book() { Id = 101, Name = "C#程式設計", Price = 79.5f };

            //物件序列化為json
            string result = SerializerHelper.ObjectToJson(book);
            Console.WriteLine(result);

            //json反序列化為物件
            string oriStr = "{\"Id\":101,\"Name\":\"C#程式設計\",\"Price\":79.5}";
            Book outBook = SerializerHelper.JsonToObject<Book>(oriStr);
            Console.WriteLine($"{outBook.Id} {outBook.Name} {outBook.Price}");

            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

二、序列化為xml

C#中將物件序列化和反序列化為xml的類是XmlSerializer，要參考System.Xml.Serialization，

首先創建一個XmlSerializer物件實體，然后用實體的Serialize方法將物件寫入到檔案流中，代碼如下：

    public class Program
    {
        /// <summary>
        /// Book類
        /// </summary>
        [DataContract]
        public class Book
        {
            [DataMember]
            public int Id { get; set; }

            [DataMember]
            public string Name { get; set; }

            [DataMember]
            public float Price { get; set; }
        }

        static void Main(string[] args)
        {
            #region 物件序列化為xml(檔案流)
            Book book = new Book() { Id = 101, Name = "C#程式設計", Price = 79.5f };

            XmlSerializer xmlSerializer = new XmlSerializer(typeof(Book));
            using (FileStream stream = new FileStream(@"E:\book.xml", FileMode.OpenOrCreate))
            {
                xmlSerializer.Serialize(stream, book);
            }
            Console.Read();
            #endregion
        }
    }

View Code

程式運行后會在c盤產生一個book.xml檔案，內容如下：

<?xml version="1.0"?>
<Book xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Id>101</Id>
  <Name>C#程式設計</Name>
  <Price>79.5</Price>
</Book>

當然也可以將物件轉換成物件流，然后轉換成xml格式的字串，代碼如下：

    public class Program
    {
        /// <summary>
        /// Book類
        /// </summary>
        [DataContract]
        public class Book
        {
            [DataMember]
            public int Id { get; set; }

            [DataMember]
            public string Name { get; set; }

            [DataMember]
            public float Price { get; set; }
        }

        static void Main(string[] args)
        {
            #region 物件序列化為xml(物件流)
            Book book = new Book() { Id = 101, Name = "C#程式設計", Price = 79.5f };

            XmlSerializer xmlSerializer = new XmlSerializer(typeof(Book));
            using (MemoryStream stream = new MemoryStream())
            {
                xmlSerializer.Serialize(stream, book);
                string result = Encoding.UTF8.GetString(stream.ToArray());  //轉換成xml字串
                Console.WriteLine(result);
            }
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

將xml檔案反序列化的方法是用XmlSerializer實體的Deserialize()方法，代碼如下：

    public class Program
    {
        /// <summary>
        /// Book類
        /// </summary>
        [DataContract]
        public class Book
        {
            [DataMember]
            public int Id { get; set; }

            [DataMember]
            public string Name { get; set; }

            [DataMember]
            public float Price { get; set; }
        }

        static void Main(string[] args)
        {
            #region xml檔案反序列化為物件
            Book book = new Book() { Id = 101, Name = "C#程式設計", Price = 79.5f };

            XmlSerializer xmlSerializer = new XmlSerializer(typeof(Book));
            using (FileStream stream = new FileStream(@"E:\book.xml", FileMode.OpenOrCreate))
            {
                XmlReader xmlReader = new XmlTextReader(stream);
                Book outBook = xmlSerializer.Deserialize(xmlReader) as Book;//反序列化
                Console.WriteLine($"{outBook.Id} {outBook.Name} {outBook.Price}");
            }
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

我們同樣也可以把上面的xml序列化與反序列為封裝成泛型方法，這樣可以公用，全部代碼如下：

    public class Program
    {
        /// <summary>
        /// Book類
        /// </summary>
        [DataContract]
        public class Book
        {
            [DataMember]
            public int Id { get; set; }

            [DataMember]
            public string Name { get; set; }

            [DataMember]
            public float Price { get; set; }
        }

        /// <summary>
        /// 序列化反序列化幫助類
        /// </summary>
        public class SerializerHelper
        {
            /// <summary>
            /// 將物件序列化為xml檔案
            /// </summary>
            /// <typeparam name="T">型別</typeparam>
            /// <param name="t">物件</param>
            /// <param name="path">xml存放路徑</param>
            public static void ObjectToXml<T>(T t, string path) where T : class
            {
                XmlSerializer formatter = new XmlSerializer(typeof(T));
                using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate))
                {
                    formatter.Serialize(stream, t);
                }
            }

            /// <summary>
            /// 將物件序列化為xml字串
            /// </summary>
            /// <typeparam name="T">型別</typeparam>
            /// <param name="t">物件</param>
            public static string ObjectToXml<T>(T t) where T : class
            {
                XmlSerializer formatter = new XmlSerializer(typeof(T));
                using (MemoryStream stream = new MemoryStream())
                {
                    formatter.Serialize(stream, t);
                    string result = Encoding.UTF8.GetString(stream.ToArray());
                    return result;
                }
            }

            /// <summary>
            /// 將xml檔案反序列化為物件
            /// </summary>
            /// <typeparam name="T">型別</typeparam>
            /// <param name="t">物件</param>
            /// <param name="path">xml路徑</param>
            /// <returns>物件</returns>
            public static T XmlToObject<T>(T t, string path) where T : class
            {
                XmlSerializer formatter = new XmlSerializer(typeof(T));
                using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate))
                {
                    XmlReader xmlReader = new XmlTextReader(stream);
                    T result = formatter.Deserialize(xmlReader) as T;
                    return result;
                }
            }
        }

        static void Main(string[] args)
        {
            #region xml序列化與反序列化泛型方法
            Book book = new Book() { Id = 101, Name = "C#程式設計", Price = 79.5f };

            //物件序列化為xml
            SerializerHelper.ObjectToXml(book, @"E:\book.xml");

            //xml反序列化為物件
            Book outBook = SerializerHelper.XmlToObject(book, @"E:\book.xml");
            Console.WriteLine($"{outBook.Id} {outBook.Name} {outBook.Price}");

            Console.Read();
            #endregion
        }
    }

View Code

三、序列化為二進制檔案

C#中將物件序列化和反序列化為二進制檔案的類是BinaryFormatter，要參考System.Runtime.Serialization.Formatters.Binary，另外Book類頭要加

[Serializable]屬性，

先創建一個BinaryFormatter物件實體，然后用實體的Serialize的方法將物件寫入到檔案流中，代碼如下：

    public class Program
    {
        /// <summary>
        /// Book類
        /// </summary>
        [DataContract]
        [Serializable]
        public class Book
        {
            [DataMember]
            public int Id { get; set; }

            [DataMember]
            public string Name { get; set; }

            [DataMember]
            public float Price { get; set; }
        }

        static void Main(string[] args)
        {
            #region 物件序列化為二進制檔案
            Book book = new Book() { Id = 101, Name = "C#程式設計", Price = 79.5f };

            //物件序列化為二進制檔案
            BinaryFormatter formatter = new BinaryFormatter();
            using (FileStream stream = new FileStream(@"E:\book.txt", FileMode.OpenOrCreate))
            {
                formatter.Serialize(stream, book);
            }
            Console.Read();
            #endregion
        }
    }

View Code

可以通過BinaryFormatter型別實體的Deserialize()方法把二進制文本反序列化為物件，代碼如下：

    public class Program
    {
        /// <summary>
        /// Book類
        /// </summary>
        [DataContract]
        [Serializable]
        public class Book
        {
            [DataMember]
            public int Id { get; set; }

            [DataMember]
            public string Name { get; set; }

            [DataMember]
            public float Price { get; set; }
        }

        static void Main(string[] args)
        {
            #region 將二進制檔案反序列化為物件
            Book book = new Book() { Id = 101, Name = "C#程式設計", Price = 79.5f };

            //序列化檔案
            BinaryFormatter formatter = new BinaryFormatter();
            using (FileStream stream = new FileStream(@"E:\book.txt", FileMode.OpenOrCreate))
            {
                Book outBook = formatter.Deserialize(stream) as Book;
                Console.WriteLine($"{outBook.Id} {outBook.Name} {outBook.Price}");
            }
            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

我們同樣也可以把序列化和把序列化為二進制檔案的方法封裝成泛型方法，全部代碼如下：

    public class Program
    {
        /// <summary>
        /// Book類
        /// </summary>
        [DataContract]
        [Serializable]
        public class Book
        {
            [DataMember]
            public int Id { get; set; }

            [DataMember]
            public string Name { get; set; }

            [DataMember]
            public float Price { get; set; }
        }

        /// <summary>
        /// 序列化反序列化幫助類
        /// </summary>
        public class SerializerHelper
        {
            #region 二進制檔案序列化反序列化
            /// <summary>
            /// 將物件序列化為字串
            /// </summary>
            /// <typeparam name="T">型別</typeparam>
            /// <param name="t">實體</param>
            /// <returns>字串</returns>
            public static string ObjectToString<T>(T t)
            {
                BinaryFormatter formatter = new BinaryFormatter();
                using (MemoryStream stream = new MemoryStream())
                {
                    formatter.Serialize(stream, t);
                    string result = Encoding.UTF8.GetString(stream.ToArray());
                    return result;
                }
            }

            /// <summary>
            /// 將物件序列化為二進制檔案
            /// </summary>
            /// <typeparam name="T">型別</typeparam>
            /// <param name="t">實體</param>
            /// <param name="path">存放路徑</param>
            public static void ObjectToBinaryFile<T>(T t, string path)
            {
                BinaryFormatter formatter = new BinaryFormatter();
                using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate))
                {
                    formatter.Serialize(stream, t);
                    stream.Flush();
                }
            }

            /// <summary>
            /// 將字串反序列為物件
            /// </summary>
            /// <typeparam name="T">型別</typeparam>
            /// <param name="s">字串</param>
            /// <returns>物件</returns>
            public static T StringToObject<T>(string s) where T : class
            {
                byte[] buffer = Encoding.UTF8.GetBytes(s);
                BinaryFormatter formatter = new BinaryFormatter();
                using (MemoryStream stream = new MemoryStream(buffer))
                {
                    T result = formatter.Deserialize(stream) as T;
                    return result;
                }
            }

            /// <summary>
            /// 將二進制檔案反序列化為物件
            /// </summary>
            /// <typeparam name="T">型別</typeparam>
            /// <param name="path">路徑</param>
            /// <returns>物件</returns>
            public static T BinaryFileToObject<T>(string path) where T : class
            {
                using (FileStream stream = new FileStream(path, FileMode.Open))
                {
                    BinaryFormatter formatter = new BinaryFormatter();
                    T result = formatter.Deserialize(stream) as T;
                    return result;
                }
            }
            #endregion
        }

        static void Main(string[] args)
        {
            #region 二進制檔案序列化反序列化泛型方法
            Book book = new Book() { Id = 101, Name = "C#程式設計", Price = 79.5f };
            //物件序列化為二進制檔案
            SerializerHelper.ObjectToBinaryFile(book, @"E:\book.txt");

            //二進制檔案反序列化為物件
            Book outBook = SerializerHelper.BinaryFileToObject<Book>(@"E:\book.txt") as Book;
            Console.WriteLine($"{outBook.Id} {outBook.Name} {outBook.Price}");

            Console.Read();
            #endregion
        }
    }

View Code

運行結果如下：

轉載請註明出處，本文鏈接：https://www.uj5u.com/net/84729.html

標籤：C#

上一篇：通過反射動態呼叫外部托管Dll

下一篇：C#效率優化（4）-- 編譯器對陣列遍歷的優化