精华内容
下载资源
问答
  • c#序列化和反序列化

    2018-05-24 17:22:30
    什么叫反序列化? 就是再把介质中的东西还原成对象,把石子还原成人的过程。 在进行这些操作的时候都需要这个可以被序列化,要能被序列化,就得给类头加[Serializable]特性。 通常网络程序为了传输安全才这么做。不...
  • 在我们深入探讨C#序列化和反序列化之前我们先要明白什么是序列化,它又称串行化,是.NET运行时环境用来支持用户定义类型的流化的机制。序列化就是把一个对象保存到一个文件或数据库字段中去,序列化就是在适当的...
  • 下面是我的WinForm的UI识别代码逻辑效果如何你解析的JSON不是多个对象,而是一个,如: 那么执行效果如图:好的,作为辅助,我创建了一个classPerson,代码如下:然后就是主逻辑代码:如下,上面用到了很多方法,...
  • 自己写的C#序列化和反序列化案例,打开软件添加信息序列化到文本,打开软件将文本信息显示到软件Dategridview控件
  • C#序列化和反序列化

    2015-05-29 10:05:21
    该文件时对C#中的序列化(Serialize)和反序列化(Deserialize)的简单应用源码
  • C# 序列化反序列化

    2019-04-15 13:48:11
    C# XmlSerializer 分别为对ArrayList的以及对类的实例化对象的序列化反序列化
  • 什么是 Json ? Json【javascript对象表示方法】, 它是一个轻量级的数据交换格式,我们可以很简单的来读取写它...有序的列表类型值的集合–这其中包含数组,集合,矢量,或者序列,等等。 Json有下面几种表现...
       什么是 Json ?
    
       Json【javascript对象表示方法】,
    
       它是一个轻量级的数据交换格式,我们可以很简单的来读取和写它,
    
       并且它很容易被计算机转化和生成,它是完全独立于语言的。
    

    Json支持下面两种数据结构:

    键值对的集合–各种不同的编程语言,都支持这种数据结构;
    有序的列表类型值的集合–这其中包含数组,集合,矢量,或者序列,等等。
    Json有下面几种表现形式:

     1.对象
    
           一个没有顺序的“键/值”,一个对象以花括号“{”开始,并以花括号"}"结束,
    
           在每一个“键”的后面,有一个冒号,并且使用逗号来分隔多个键值对。
    
           例如:var user = {"name":"Manas","gender":"Male","birthday":"1987-8-8"}   
    
     2.数组
    
           设置值的顺序,一个数组以中括号"["开始,并以中括号"]"结束,
    
           并且所有的值使用逗号分隔,
    
           例如:
    
                   var userlist = [
    
                                           {"user":{"name":"Manas","gender":"Male","birthday":"1987-8-8"}}, 
                                           {"user":{"name":"Mohapatra","Male":"Female","birthday":"1987-7-7"}}
    
                                           ]
    
     3.字符串
    
            任意数量的Unicode字符,使用引号做标记,并使用反斜杠来分隔。
    
            (注意: 引号  逗号  冒号  均为英文状态下半角符号, 且只能是双引号 )
    
            例如: var userlist = "{\"ID\":1,\"Name\":\"Manas\",\"Address\":\"India\"}" 
    

    C#中具体如何使用:

           在C#中我们经常使用下面的工具来解析Json格式的内容
    
            Newtonsoft.Json,是.Net中开源的Json序列化和反序列化工具,官方地址:http://www.newtonsoft.com/json。
    

    具体使用:

    1. 右键项目=>Nuget包管理=>添加 Newtonsoft.Json

    2. 引入命名空间
      1 using Newtonsoft.Json;

    3. 定义类

    public class Student
    {
    public int ID { get; set; }

    public string Name { get; set; }
    
    public int Age { get; set; }
    
    public string Sex { get; set; }
    

    }

    1. 序列化和反序列化实体对象
    //序列化对象
        Student MES= new Student()
        { ID = 1, Name = "武松", Age = 250, Sex = "男" }; 
    
    //序列化
    string jsonData = JsonConvert.SerializeObject(MES); 
    //保存数据
    File.WriteAllText("mes.json", jsonData); 
    //读取数据
    jsonsting = File.ReadAllText("mes.json");
    //反序列化
     Mes = JsonConvert.DeserializeObject<Student >(jsonsting );
    
    1. 序列化实体对象集合
      //序列化对象集合
       List<Student> oneList = new List<Student>() {
            new Student{ ID = 1, Name = "武大", Age = 260, Sex = "男" },
            new Student{ ID = 2, Name = "武二", Age = 250, Sex = "男" },
            new Student{ ID = 3, Name = "武三", Age = 240, Sex = "女" }
       }; //定义对象
    
    
    ```csharp
      string jsonData = JsonConvert.SerializeObject(oneList); //序列化
    
    
     
    
    
    
    6. 反序列化实体对象集合
    
    
    ```csharp
       List<Student> twoList = JsonConvert.DeserializeObject<List<Student>>(jsonData);
    
       foreach(Student stu in twoList)
       {
            Console.WriteLine(
            string.Format("学生信息  ID:{0},姓名:{1},年龄:{2},性别:{3}",
                  stu.ID, stu.Name, stu.Age, stu.Sex));//显示结果   
        }
        Console.ReadLine();
    

    7构成叠加层级

    public class MESMSG
            {
                public string MesID;
                public string PCID;
                public string PCPort;
                public string SITE;
    
            }
            public class MESMSG2
            {
                public string MesID;
                public MESMSG mes;          
            }
             public static string writetest2(string h)
            {
                MESMSG m = new MESMSG()
                {
                    MesID = "1",
                    PCID = "1",
                    PCPort = "1",
                    SITE = "1"
                };
                MESMSG2 tt = new MESMSG2();
                tt.MesID = "2";
                tt.mes = m;
                string jsonData = JsonConvert.SerializeObject(tt);
                return jsonData;
            }
    

    结果:
    “{“MesID”:“2”,“mes”:{“MesID”:“1”,“PCID”:“1”,“PCPort”:“1”,“SITE”:“1”}}”

    展开全文
  • 主要介绍了C#中datatable序列化反序列化,是datatable的常用技巧,需要的朋友可以参考下
  • 此资源是《C#序列化和反序列化之一-二进制序列化》的源代码,博文地址是:http://blog.csdn.net/jiangzhanchang/article/details/6892262
  • 详解C# 序列化和反序列化

    千次阅读 2019-11-04 21:50:01
    今天我利用这篇文章给大家讲解一下 C# 中的序列化反序列化。这两个概念我们在开发中经常用到,但是我们绝大部分只用到了其中的一部分,剩下的部分很多开发人员并不清楚,伸着可以说是不知道。因此我希望通过这篇...

    今天我利用这篇文章给大家讲解一下 C# 中的序列化与反序列化。这两个概念我们在开发中经常用到,但是我们绝大部分只用到了其中的一部分,剩下的部分很多开发人员并不清楚,伸着可以说是不知道。因此我希望通过这篇文章能让各位对序列化和反序列化的知识有更进一步的掌握。废话不多说开始进入正题。

    零、什么是序列化/反序列化

    在所有的开发语言中都存在序列化和反序列化这个概念,所谓的序列化就是把一个对象信息转化为一个可以持久存储的数据形式,经过转化后就可以方便的保存和传输了,因此序列化主要用于平台之间的通讯。由序列化我们可以反推出所谓的反序列化就是将持久存储的数据还原为对象。

    一、c# 中的序列化/反序列化

    在 c# 中我们经常会对 JSON 和 XML 进行序列化和反序列化 ,但是还有存在一种序列化/反序列化,那就是将对象序列化为二进制文件,将会二进制文件反序列化为对象。下面我将会对这三种序列化和反序列化进行讲解。

    1. JSON
      JSON 的英文全称是 JavaScript Object Notation ,是一种轻量级的数据交换格式。完全独立于语言的文本格式 易于人阅读和编写同时也易于机器解析和生成。JSON 是目前互联网中主流的数据交换格式,同时也是很多开发语言配置文件的主流格式。
      在 .NET 中存在两个类对 JSON 进行处理,分别是 DataContractJsonSerializer 和 JavaScriptSerializer ,这两个类的功能基本一致。 DataContractJsonSerializer 位于命名空间 System.Runtime.Serialization.Json 下,它的特点是必须使用 DataContract 以及 DataMember 属性标记成员。 JavaScriptSerializer 位于命名空间 System.Web.Script.Serialization 下,通过名字和它所在的命名空间我们可以得知它主要用在网络通信中,它可以序列化任何类型的对象。同样 .NET 中也存在一个强大的第三方 JSON 序列化/反序列化库 Newtonsoft.Json ,他比前两个类用起来要方便很多。下面我们对这三个序列化/反序列化的方式分别进行讲解。
    • DataContractJsonSerializer
      首先我们需要在项目中引用 DataContractJsonSerializer 所在的命名空间,这里要注意的时我们不仅要在项目中添加引用 System.Runtime.Serialization 还需要添加引用 System.ServiceModel.Web 。将这两个命名空添加到命名空间后就可以在代码中引入 DataContractJsonSerializer 的命名空间了。
    using System.Runtime.Serialization;
    using System.Runtime.Serialization.Json;
    

    引入命名空间后我们开始编写序列化类

    [DataContract]
    class Student
    {
        [DataMember]
        public string Name { get; set; }
        [DataMember]
        public int Sex { get; set; }
        [DataMember]
        public int Age { get; set; }
        [DataMember]
        public Address Address { get; set;  }
    }
    [DataContract]
    class Address
    {
        [DataMember]
        public string City { get; set; }
        [DataMember]
        public string Road { get; set; }
    }
    

    在上述代码中我们看到在类的头部添加了 DataContract 特性,以及在类的属性上也增加了 DataMember 特性 。一旦一个类被声明为 DataContract 时就代表着该类可以被序列化,并且可以在服务端和客户端传输。只有声明为DataContract的类型的对象可以被传送,且只有成员属性会被传递,成员方法不会被传递。默认情况下类中的所有成员属性都不会被序列化传输出去,如果需要将成员数据传输出去就需要在属性头部加入 DataMember 。
    下面我们就利用 DataContractJsonSerializer 对对象尽心序列化和反序列化,代码如下

    class Program
    {
        static void Main(string[] args)
        {
            #region 对象转JSON字符串
            Student student = new Student
            {
                Name = "Tom",
                Age = 20,
                Sex = 1,
                Address = new Address
                {
                    City = "NYC",
                    Road = "ABC"
                }
            };
            //利用WriteObject方法序列化为 JSON
            DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Student));
            MemoryStream stream = new MemoryStream();
            serializer.WriteObject(stream, student);
            byte[] bytes=new byte[stream.Length];
            stream.Position = 0;
            stream.Read(bytes, 0, (int)stream.Length);
            string jsonStr = Encoding.UTF8.GetString(bytes);
            Console.WriteLine(jsonStr);
            #endregion
    
            #region JSON字符串转对象
            stream = new MemoryStream(Encoding.Default.GetBytes(jsonStr));
            student = (Student)serializer.ReadObject(stream);
            Console.WriteLine("Name: " +student.Name);
            Console.WriteLine("Sex: " + student.Sex);
            Console.WriteLine("Age: " + student.Age);
            Console.WriteLine("Address: " + student.Address.City+" "+student.Address.Road);
            #endregion
            Console.ReadLine();
        }
    }
    

    输出结果如下:
    在这里插入图片描述

    • JavaScriptSerializer
      我们利用前面定义的类,来看一下 JavaScriptSerializer 的使用方法,我们将前面定义的类中的 DataContract 和 DataMember 都去掉。我们如果要使用 JavaScriptSerializer 只需引入 System.Web.Script.Serialization 命名空间即可。代码如下:
    using System.Web.Script.Serialization;
    

    下面我们就利用 JavaScriptSerializer 对象进行序列化和反序列化,代码如下:

    class Program
    {
        static void Main(string[] args)
        {
            #region 序列化
            Student student = new Student
            {
                Name = "Tom",
                Age = 20,
                Sex = 1,
                Address = new Address
                {
                    City = "NYC",
                    Road = "ABC"
                }
            };
            //初始化
            JavaScriptSerializer serializer = new JavaScriptSerializer();
            string jsonStr = serializer.Serialize(student);
            Console.WriteLine(jsonStr);
            #endregion
    
            #region 反序列化
            student = serializer.Deserialize<Student>(jsonStr);
            Console.WriteLine("Name: " +student.Name);
            Console.WriteLine("Sex: " + student.Sex);
            Console.WriteLine("Age: " + student.Age);
            Console.WriteLine("Address: " + student.Address.City+" "+student.Address.Road);
            #endregion
            Console.ReadLine();
        }
    }
    

    从上面的代码我们可以看出利用 JavaScriptSerializer 序列化和反序列化要比 DataContractJsonSerializer 类方便。上述代码运行结果如下:
    Kg2T2j.png

    • Newtonsoft.Json
      Newtonsoft.Json 功能有很多,除了序列化反序列化之外,还有 Linq To Json、Json Path、 XML support等,我们这篇文章我们只讲解其中的序列化和反序列化。使用 Newtonsoft.Json 前首先我们需要在 nuget 中搜索并安装,安装完成后引入 Newtonsoft.Json,代码如下:
    using Newtonsoft.Json;
    

    下面我们来看看 Newtonsoft.Json 的具体使用:

    class Program
    {
        static void Main(string[] args)
        {
            #region 序列化
            Student student = new Student
            {
                Name = "Tom",
                Age = 20,
                Sex = 1,
                Address = new Address
                {
                    City = "NYC",
                    Road = "ABC"
                }
            };
            string jsonStr = JsonConvert.SerializeObject(student);
            Console.WriteLine(jsonStr);
            #endregion
    
            #region 反序列化
            student = JsonConvert.DeserializeObject<Student>(jsonStr);
            Console.WriteLine("Name: " +student.Name);
            Console.WriteLine("Sex: " + student.Sex);
            Console.WriteLine("Age: " + student.Age);
            Console.WriteLine("Address: " + student.Address.City+" "+student.Address.Road);
            #endregion
    
            Console.ReadLine();
        }
    }
    

    上述代码输出结果如下:
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rW1zuZaS-1572875384497)(https://s2.ax1x.com/2019/10/28/KgRz0P.png)]
    从代码中我们看到 Newtonsoft.Json 序列化和反序列化更加简单,简单到只需要一行代码就完成了序列化和反序列化。
    2. XML
    在 JSON 还没出现之前,XML 是互联网上常用的数据交换格式和规范。.NET 中提供 XmlSerializer 类将对象序列化为 XML 和将 XML 反序列化为对象,使用方法是首先实例化,然后调用序列化/反序列化方法。下面我们依然使用最开始定义的那个类,来看看 XmlSerializer 的使用。使用前我们需要引入 using System.Xml.Serialization 命名空间。

    using System.Xml.Serialization;
    

    具体序列化/反序列化方法如下:

    class Program
    {
        static void Main(string[] args)
        {
            #region 序列化
            Student student = new Student
            {
                Name = "Tom",
                Age = 20,
                Sex = 1,
                Address = new Address
                {
                    City = "NYC",
                    Road = "ABC"
                }
            };
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(Student));
            using (FileStream stream = new FileStream(@"d:\123.xml", FileMode.OpenOrCreate))
            {
                xmlSerializer.Serialize(stream, student);
            }
            #endregion
    
            #region 反序列化
            using (FileStream stream = new FileStream(@"d:\123.xml", FileMode.OpenOrCreate))
            {
                XmlReader xmlReader = new XmlTextReader(stream);
                student = xmlSerializer.Deserialize(xmlReader) as Student;
            }
            Console.WriteLine("Name: " + student.Name);
            Console.WriteLine("Sex: " + student.Sex);
            Console.WriteLine("Age: " + student.Age);
            Console.WriteLine("Address: " + student.Address.City + " " + student.Address.Road);
            #endregion
    
            Console.ReadLine();
        }
    }
    

    这里有一点需要注意,如果对象类的访问修饰符不是 public 将会报错。上述代码运行结果如下:
    Kg4Dc4.png
    Kg4RN6.md.png
    3. 二进制
    序列化为二进制,在实际开发中真的很少用到,但是我觉得还是有必要讲一讲,它的使用方法和 XmlSerializer 序列化/反序列化类似,首先实例化,然后调用序列化/反序列化方法。在进行序列化/反序列化前首先引入命名空间 System.Runtime.Serialization.Formatters.Binary ,同时修改对象类如下:

    [Serializable]
    public class Student
    {
       public string Name { get; set; }
       public int Sex { get; set; }
       public int Age { get; set; }
       public Address Address { get; set; }
    }
    [Serializable]
    public class Address
    {
       public string City { get; set; }
       public string Road { get; set; }
    }
    

    上述代码中我们在类的头部加入了 Serializable 特性,这代表着整个类对象都需要序列化,如果我们不需要序列化其中某个属性的话只需在该属性上加上 NonSerialized 特性即可。下面我们来看一下序列化和反序列化的代码:

    class Program
    {
        static void Main(string[] args)
        {
            #region 序列化
            Student student = new Student
            {
                Name = "Tom",
                Age = 20,
                Sex = 1,
                Address = new Address
                {
                    City = "NYC",
                    Road = "ABC"
                }
            };
            BinaryFormatter binFormat = new BinaryFormatter();
            string fileName = Path.Combine(@"D:\", @"321.txt");
            using (Stream fStream = new FileStream(fileName, FileMode.Create, FileAccess.ReadWrite))
            {
                binFormat.Serialize(fStream, student);
            }
            #endregion
    
            #region 反序列化
            using (Stream fStream = new FileStream(fileName, FileMode.Open, FileAccess.ReadWrite))
            {
                fStream.Position = 0;
                student = (Student)binFormat.Deserialize(fStream);
            }
            Console.WriteLine("Name: " + student.Name);
            Console.WriteLine("Sex: " + student.Sex);
            Console.WriteLine("Age: " + student.Age);
            Console.WriteLine("Address: " + student.Address.City + " " + student.Address.Road);
            #endregion
    
            Console.ReadLine();
        }
    }
    

    上述代码最终输出结果如下:
    KgqVoj.png

    二、总结

    这篇文章详细讲解了.NET中序列化和反序列化相关知识的使用,序列化和反序列化相关的只是还有很多,这里所讲解的都是开发中经常用到的,也是面试过程中会提及的,因此大家需要牢记。

    展开全文
  • 实现C#序列化和反序列化XML-读取wordXML内容
  • 下面小编就为大家带来一篇浅谈C# 序列化反序列化几种格式的转换。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 典型的C#的树形图操作,很多需要实现简单编程系统的参考,需要控件能解析成类的实例并保存,也需要读取文件反向解析为类的实例
  • 基于WindowForm应用程序C#语言通过实际案例实现将对象保存到文件及从已保存的文件中读取对象(直接保存与读取、通过序列化反序列化方式进行对象保存与读取)
  • 实现了用三种序列化方式(binary,soap,xml)序列化对象,其中Student对象中还包含图片(用binarysoap),School中没有图片(用XML)。
  • c#对象序列化反序列化实例c#对象序列化反序列化实例c#对象序列化反序列化实例c#对象序列化反序列化实例c#对象序列化反序列化实例c#对象序列化反序列化实例
  • C#序列化和反序列化到底是什么意思

    千次阅读 2015-05-22 16:17:03
    源自:...序列化就是把一个对象保存到一个文件或数据库字段中去,反序列化就是在适当的时候把这个文件再转化成原来的对象使用。 我想最主要的作用有: 1
    源自:http://zhidao.baidu.com/link?url=7Ax5j_olBu_q3FzzMnyx1hV1uacZnt9b20k2Hq8aa8BKg_by9xktvUFLigValYA86XcoFQNbCj1UaMHn_62kHa
    回答1:
    序列化就是把一个对象保存到一个文件或数据库字段中去,反序列化就是在适当的时候把这个文件再转化成原来的对象使用。 
    我想最主要的作用有: 
    1、在进程下次启动时读取上次保存的对象的信息 
    2、在不同的AppDomain或进程之间传递数据 
    3、在分布式应用系统中传递数据
    回答2:
    序列化,其实就是将对象的状态信息转换为可以存储或传输的数据形式。

    比如有这样一个类

    class User{
    public string UserName;
    public string Password;
    }

    我们可以把它的实例转换为这样的xml
    <User>
    <UserName>value</UserName>
    <Password>value</Password>
    </User>
    可以认为这样就是序列化。
    回答3:
    你就这样理解就行了,序列化就是将对象变成一堆字符,反序列化就是将这堆字符还原成对象。 
    楼上的兄弟,序列化可不一定会保存到文件或数据库中哦,可能只在内存中。
    展开全文
  • c#中的序列化和反序列化

    千次阅读 2019-08-13 21:25:48
    第一步:什么是序列化和反序列化 序列化定义:将对象转化为容易传输的格式的过程。 反序列化定义:重新解析构造被序列化的对象 第二步:为什么要序列化和反序列化 当两个进程在进行远程通信时,彼此可以发送各种...

    第一步:什么是序列化和反序列化

    序列化定义:将对象转化为容易传输的格式的过程。
    反序列化定义:重新解析构造被序列化的对象

    第二步:为什么要序列化和反序列化

    1. 当两个进程在进行远程通信时,彼此可以发送各种类型的数据。无论是何种类型的数据,都会以二进制序列的形式在网络上传送。发送方需要把这个对象转换为字节序列,才能在网络上传送;接收方则需要把字节序列再回复为对象。
    2. 我们经常需要将对象的字段值保存在磁盘中。并在以后检索此数据。尽管不适用序列化也能完成这项工作,单这样方法通常很繁琐而且容易出错,并且在需要跟踪对象的层次结构时,会变得越来越复杂。可以想象一下编写包含大量对象的大型业务应用程序的情形:程序员不得不为每一个对象编写代码,以便将字段和属性保存至磁盘以及从磁盘还原这些字段和属性。序列化提供了轻松实现这个目标的快捷方法。
    3. NET公共语言运行时(CLR)管理对象在内存中的分布,.NET框架则通过使用反射提供自动的序列化机制。对象序列化后,类的名称、程序集以及类实例的所有数据成员均被写入存储媒体中。对象通常用成员变量来存储对其它实例的引用。类序列化后,序列化引擎将跟踪所有已序列化的引用对象,以确保同一对象不被序列化多次。.NET框架所提供的序列化体系结构可以自动正确处理对象图标和循环引用。对图表的唯一要求是,由正在进行序列化的对象所引用的所有对象都必须标记为Serializable。否则,当序列化程序试图序列化未标记的对象时将会出现异常。

    第三步:序列化和反序列化方法

    NET框架提供了两种串行化的方式:
    1、是使用BinaryFormatter进行串行化;
    2、使用SoapFormatter进行串行化;
    3、使用XmlSerializer进行串行化。
    第一种方式提供了一个简单的二进制数据流以及某些附加的类型信息,而第二种将数据流格式化为XML存储;第三种其实和第二种差不多也是XML的格式存储,只不过比第二种的XML格式要简化很多(去掉了SOAP特有的额外信息)。可以使用[Serializable]属性将类标志为可序列化的。如果某个类的元素不想被序列化,1、2可以使用[NonSerialized]属性来标志,2、可以使用[XmlIgnore]来标志。

    第四步:实例

    1、创建一个可序列化的类

    namespace test1
    {
        [Serializable]
        public class Person
        {
            public string sno { get; set; }
            public string name { get; set; }
            public string sex { get; set; }
            public int age { get; set; }
            public string displayInfo()
            {
                return "我的学号是:" + sno + "\n我的名字是:" + name + "\n我的性别为:" + sex + "\n我的年龄:" + age + "\n";
            }
        }
    }
    

    2、BinaryFormatter序列化方式

    private void btn_start_Click(object sender, EventArgs e)
            {
                Person me = new Person
                {
                    sno = "200719",
                    name="yyyyyyy",
                    sex="man",
                    age=22
                };
                //创建一个格式化程序实例
                IFormatter formatter = new BinaryFormatter();
                try
                {
                    //创建一个文件流,如果D盘目录下没有就会自动创建一个此文件
                    Stream stream = new FileStream("D:/personInfo.txt",FileMode.OpenOrCreate,FileAccess.Write,FileShare.None);
                    formatter.Serialize(stream, me);
                    stream.Close();
                }
                catch(Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
                
            }
    

    执行这个序列化程序后就会在D盘根路径创建一个personInfo.txt文件。
    反序列:

    private void btn_start_Click(object sender, EventArgs e)
            {
                //创建一个格式化程序的实例
                IFormatter foramtter = new BinaryFormatter();
                Stream destream = new FileStream("D:/personInfo.txt", FileMode.Open, FileAccess.Read, FileShare.Read);
                var stillme = (Person)foramtter.Deserialize(destream);
                Console.WriteLine(stillme.displayInfo()); 
            }
    

    在这里插入图片描述

    3、SoapFormatter序列化方式

    private void btn_start_Click(object sender, EventArgs e)
            {
                Person me = new Person
                {
                    sno = "200719",
                    name = "yyyyyyy",
                    sex = "man",
                    age = 22
                };
                //创建一个格式化程序实例
                IFormatter formatter = new SoapFormatter(); 
                try
                {
                    //创建一个文件流
                    Stream stream = new FileStream("c:/personInfo.txt", FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
                    formatter.Serialize(stream, me);
                    stream.Close();
                    Console.WriteLine("序列化结束!\n");
                    Console.WriteLine("反序列化开始……");
    
                    //反序列化
                    Stream destream = new FileStream("c:/personInfo.txt", FileMode.Open,
                    FileAccess.Read, FileShare.Read);
                    var stillme = (Person)formatter.Deserialize(destream);
                    stream.Close();
                    Console.WriteLine("反序列化结束,输出对象信息……");
                    Console.WriteLine(stillme.displayInfo());
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
    

    4、XML序列化方式

    private void btn_start_Click(object sender, EventArgs e)
            {
                Person me = new Person
                {
                    sno = "200719",
                    name = "yyyyyyy",
                    sex = "man",
                    age = 22
                };
                //创建一个格式化程序实例
                XmlSerializer formatter = new XmlSerializer(typeof(Person));
                try
                {
                    //创建一个文件流
                    Stream stream = new FileStream("c:/personInfo.txt", FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
                    formatter.Serialize(stream, me);
                    stream.Close();
                    Console.WriteLine("序列化结束!\n");
                    Console.WriteLine("反序列化开始……");
    
                    //反序列化
                    Stream destream = new FileStream("c:/personInfo.txt", FileMode.Open,
                    FileAccess.Read, FileShare.Read);
                    var stillme = (Person)formatter.Deserialize(destream);
                    stream.Close();
                    Console.WriteLine("反序列化结束,输出对象信息……");
                    Console.WriteLine(stillme.displayInfo());
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
    

    结果:
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • C# xml序列化反序列化(解析xml为对象及对象转xml保存),方法一反序列化取节点KV值,方法二反序列化取节点标签值,方法三取节点KV值,并增加节点对象数组及节点标签组合反序列化
  • 本文实例讲述了C#序列化序列化(Serialize,Deserialize)实现方法。分享给大家供大家参考。具体分析如下: 如果要保存运行程序过程的数据要么保存到数据库中,要么新建一个普通的文件,然后把数据保存进去.但是这...
  • c#序列化详解示例

    2020-12-31 14:06:36
    2)XML 序列化序列化公共属性字段,且不保持类型保真度。当您要提供或使用数据而不限制使用该数据的应用程序时,这一点是很有用的。由于 XML 是一个开放式标准,因此,对于通过 Web 共享数据而言,这是一个很好...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 74,013
精华内容 29,605
关键字:

c#序列化和反序列化

c# 订阅