C#序列化與反序列化學(xué)習(xí)筆記

Coder編程 2020-04-25

展開全文

本筆記摘抄自：https://www.cnblogs.com/maitian-lf/p/3670570.html，記錄一下學(xué)習(xí)過程以備后續(xù)查用。

序列化是把一個內(nèi)存中的對象的信息轉(zhuǎn)化成一個可以持久化保存的形式，以便于保存或傳輸。序列化的主要作用是不同平臺之間進(jìn)行通信，常用的序

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

一、序列化為json

C#中用于對象和json相互轉(zhuǎn)換的原生類有兩個：DataContractJsonSerializer和JavaScriptSerializer，其中JavaScriptSerializer主要用于web瀏覽器和服

務(wù)器之間的通信。這里主要講DataContractJsonSerializer的使用，要使用DataContractJsonSerializer，先要在項(xiàng)目中引用System.Runtime.Serialization。

首先準(zhǔn)備一個測試的類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]指定該類型要定義或?qū)崿F(xiàn)一個數(shù)據(jù)協(xié)定，并可由序列化程序（如System.Runtime.Serialization.DataContractSerializer）進(jìn)行序列化。

[DataMember]當(dāng)應(yīng)用于類型的成員時，指定該成員是數(shù)據(jù)協(xié)定的一部分并可由System.Runtime.Serialization.DataContractSerializer進(jìn)行序列化。

首先創(chuàng)建一個Book對象，然后實(shí)例化一個DataContractJsonSerializer實(shí)例，最后用該實(shí)例的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#程序設(shè)計(jì)", 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

運(yùn)行結(jié)果如下：

將一個json格式的字符串反序列化為對象是用DataContractJsonSerializer實(shí)例的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#程序設(shè)計(jì)\",\"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

運(yùn)行結(jié)果如下：

我們也可以把上面的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">實(shí)例</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">實(shí)例</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#程序設(shè)計(jì)", Price = 79.5f };

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

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

            Console.Read();
            #endregion
        }
    }

View Code

運(yùn)行結(jié)果如下：

二、序列化為xml

C#中將對象序列化和反序列化為xml的類是XmlSerializer，要引用System.Xml.Serialization。

首先創(chuàng)建一個XmlSerializer對象實(shí)例，然后用實(shí)例的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#程序設(shè)計(jì)", 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

程序運(yùn)行后會在c盤產(chǎn)生一個book.xml文件，內(nèi)容如下：

<?xml version="1.0"?>
<Book xmlns:xsi="http://www./2001/XMLSchema-instance" xmlns:xsd="http://www./2001/XMLSchema">
  <Id>101</Id>
  <Name>C#程序設(shè)計(jì)</Name>
  <Price>79.5</Price>
</Book>

當(dāng)然也可以將對象轉(zhuǎn)換成對象流，然后轉(zhuǎn)換成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#程序設(shè)計(jì)", 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());  //轉(zhuǎn)換成xml字符串
                Console.WriteLine(result);
            }
            Console.Read();
            #endregion
        }
    }

View Code

運(yùn)行結(jié)果如下：

將xml文件反序列化的方法是用XmlSerializer實(shí)例的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#程序設(shè)計(jì)", 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

運(yùn)行結(jié)果如下：

我們同樣也可以把上面的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#程序設(shè)計(jì)", 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

三、序列化為二進(jìn)制文件

C#中將對象序列化和反序列化為二進(jìn)制文件的類是BinaryFormatter，要引用System.Runtime.Serialization.Formatters.Binary，另外Book類頭要加

[Serializable]屬性。

先創(chuàng)建一個BinaryFormatter對象實(shí)例，然后用實(shí)例的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 對象序列化為二進(jìn)制文件
            Book book = new Book() { Id = 101, Name = "C#程序設(shè)計(jì)", Price = 79.5f };

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

View Code

可以通過BinaryFormatter類型實(shí)例的Deserialize()方法把二進(jìn)制文本反序列化為對象，代碼如下：

    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 將二進(jìn)制文件反序列化為對象
            Book book = new Book() { Id = 101, Name = "C#程序設(shè)計(jì)", 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

運(yùn)行結(jié)果如下：

我們同樣也可以把序列化和把序列化為二進(jìn)制文件的方法封裝成泛型方法，全部代碼如下：

    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 二進(jìn)制文件序列化反序列化
            /// <summary>
            /// 將對象序列化為字符串
            /// </summary>
            /// <typeparam name="T">類型</typeparam>
            /// <param name="t">實(shí)例</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>
            /// 將對象序列化為二進(jìn)制文件
            /// </summary>
            /// <typeparam name="T">類型</typeparam>
            /// <param name="t">實(shí)例</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>
            /// 將二進(jìn)制文件反序列化為對象
            /// </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 二進(jìn)制文件序列化反序列化泛型方法
            Book book = new Book() { Id = 101, Name = "C#程序設(shè)計(jì)", Price = 79.5f };
            //對象序列化為二進(jìn)制文件
            SerializerHelper.ObjectToBinaryFile(book, @"E:\book.txt");

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

            Console.Read();
            #endregion
        }
    }

View Code

運(yùn)行結(jié)果如下：

本站是提供個人知識管理的網(wǎng)絡(luò)存儲空間，所有內(nèi)容均由用戶發(fā)布，不代表本站觀點(diǎn)。請注意甄別內(nèi)容中的聯(lián)系方式、誘導(dǎo)購買等信息，謹(jǐn)防詐騙。如發(fā)現(xiàn)有害或侵權(quán)內(nèi)容，請點(diǎn)擊一鍵舉報(bào)。

轉(zhuǎn)藏 分享

QQ空間 QQ好友新浪微博微信

獻(xiàn)花（0） +1

來自： Coder編程 > 《待分類》

舉報(bào)/認(rèn)領(lǐng)