1.对象序列化的介绍

(1).NET支持对象序列化的几种方式

二进制序列化:对象序列化之后是二进制形式的,通过BinaryFormatter类来实现的,这个类位于System.Runtime.Serialization.Formatters.Binary命名空间下。

SOAP序列化:对象序列化之后的结果符合SOAP协议,也就是可以通过SOAP 协议传输,通过System.Runtime.Serialization.Formatters.Soap命名空间下的SoapFormatter类来实现的。

XML序列化:对象序列化之后的结果是XML形式的,通过XmlSerializer 类来实现的,这个类位于System.Xml.Serialization命名空间下。XML序列化不能序列化私有数据。

(2)几种序列化的区别

二进制格式和SOAP格式可序列化一个类型的所有可序列化字段,不管它是公共字段还是私有字段。XML格式仅能序列化公共字段或拥有公共属性的私有字段,未通过属性公开的私有字段将被忽略。

使用二进制格式序列化时,它不仅是将对象的字段数据进行持久化,也持久化每个类型的完全限定名称和定义程序集的完整名称(包括包称、版本、公钥标记、区域性),这些数据使得在进行二进制格式反序列化时亦会进行类型检查。SOAP格式序列化通过使用XML命名空间来持久化原始程序集信息。而XML格式序列化不会保存完整的类型名称或程序集信息。这便利XML数据表现形式更有终端开放性。如果希望尽可能延伸持久化对象图的使用范围时,SOAP格式和XML格式是理想选择。

(3)使用特性对序列化的控制

要让一个对象支持.Net序列化服务,用户必须为每一个关联的类加上[Serializable]特性。如果类中有些成员不适合参与序列化(比如:密码字段),可以在这些域前加上[NonSerialized]特性。

2.使用二进制序列化和反序列化

(1)二进制序列化与反序列化的程序示例

   [Serializable]  //必须添加序列化特性

     public class Person

     {

         private string Name;//姓名

         private bool Sex;//性别,是否是男

         public Person(string name, bool sex)

         {

             this.Name = name;

             this.Sex = sex;

         }

         public override string ToString()

         {

             return "姓名:" + this.Name + "\t性别:" + (this.Sex ? "男" : "女");

         }

     }

     [Serializable]  //必须添加序列化特性

     public class Programmer : Person

     {

         private string Language;//编程语言

         public Programmer(string name, bool sex, string language) : base(name, sex)

         {

             this.Language = language;

         }

         public override string ToString()

         {

             return base.ToString() + "\t编程语言:" + this.Language;

         }

     }

     class Program

     {

         static void Main(string[] args)

         {

             //创建Programmer列表,并添加对象

             List<Programmer> list = new List<Programmer>();

             list.Add(new Programmer("李志伟", true, "C#"));

             list.Add(new Programmer("Coder2", false, "C++"));

             list.Add(new Programmer("Coder3", true, "Java"));

             //使用二进制序列化对象

             string fileName = @"D:\users\lizw\桌面\Programmers.dat";//文件名称与路径

             Stream fStream = new FileStream(fileName, FileMode.Create, FileAccess.ReadWrite);

             BinaryFormatter binFormat = new BinaryFormatter();//创建二进制序列化器

             binFormat.Serialize(fStream, list);

             //使用二进制反序列化对象

             list.Clear();//清空列表

             fStream.Position = ;//重置流位置

             list = (List<Programmer>)binFormat.Deserialize(fStream);//反序列化对象

             foreach (Programmer p in list)

             {

                 Console.WriteLine(p);

             }

             Console.Read();

         }

     }

(2)总结

使用二进制序列化,必须为每一个要序列化的的类和其关联的类加上[Serializable]特性,对类中不需要序列化的成员可以使用[NonSerialized]特性。

二进制序列化对象时,能序列化类的所有成员(包括私有的),且不需要类有无参数的构造方法。

使用二进制格式序列化时,它不仅是将对象的字段数据进行持久化,也持久化每个类型的完全限定名称和定义程序集的完整名称(包括包称、版本、公钥标记、区域性),这些数据使得在进行二进制格式反序列化时亦会进行类型检查。所以反序列化时的运行环境要与序列化时的运行环境要相同,否者可能会无法反序列化成功。

3.使用SOAP方式序列化和反序列化

(1)SOAP序列化与反序列化的程序示例

 [Serializable]  //必须添加序列化特性

     public class Person

     {

         private string Name;//姓名

         private bool Sex;//性别,是否是男

         public Person(string name, bool sex)

         {

             this.Name = name;

             this.Sex = sex;

         }

         public override string ToString()

         {

             return "姓名:" + this.Name + "\t性别:" + (this.Sex ? "男" : "女");

         }

     }

     [Serializable]  //必须添加序列化特性

     public class Programmer : Person

     {

         private string Language;//编程语言

         public Programmer(string name, bool sex, string language) : base(name, sex)

         {

             this.Language = language;

         }

         public override string ToString()

         {

             return base.ToString() + "\t编程语言:" + this.Language;

         }

     }

     class Program

     {

         static void Main(string[] args)

         {

             //实例化对象

             Programmer p = new Programmer("李志伟", true, "C、C#、C++、Java");

             //使用SOAP序列化对象

             string fileName = @"D:\users\lizw\桌面\Programmers.xml";//文件名称与路径

             Stream fStream = new FileStream(fileName, FileMode.Create, FileAccess.ReadWrite);

             SoapFormatter soapFormat = new SoapFormatter();//创建SOAP序列化器

             soapFormat.Serialize(fStream, p);//SOAP不能序列化泛型对象

             //使用SOAP反序列化对象

             fStream.Position = ;//重置流位置

             p = null;

             p = (Programmer)soapFormat.Deserialize(fStream);

             Console.WriteLine(p);

             Console.Read();

         }

     }

(2)总结

SOAP序列化与二进制序列化的区别是:SOAP序列化不能序列化泛型类型。与二进制序列化一样在序列化时不需要向序列化器指定序列化对象的类型。而XML序列化需要向XML序列化器指定序列化对象的类型。

4.使用XML方式序列化和反序列化

(1)XML序列化与反序列化的程序示例

 public class Person

     {

         public string Name;//姓名

         public bool Sex;//性别,是否是男

         public Person() { }//必须提供无参构造器,否则XmlSerializer将出错

         public Person(string name, bool sex)

         {

             this.Name = name;

             this.Sex = sex;

         }

         public override string ToString()

         {

             return "姓名:" + this.Name + "\t性别:" + (this.Sex ? "男" : "女");

         }

     }

     public class Programmer : Person

     {

         public string Language;//编程语言

         public Programmer() { }//必须提供无参构造器,否则XmlSerializer将出错

         public Programmer(string name, bool sex, string language) : base(name, sex)

         {

             this.Language = language;

         }

         public override string ToString()

         {

             return base.ToString() + "\t编程语言:" + this.Language;

         }

     }

     class Program

     {

         static void Main(string[] args)

         {

             //创建Programmer列表,并添加对象

             List<Programmer> list = new List<Programmer>();

             list.Add(new Programmer("李志伟", true, "C#"));

             list.Add(new Programmer("Coder2", false, "C++"));

             list.Add(new Programmer("Coder3", true, "Java"));

             //使用XML序列化对象

             string fileName = @"D:\users\lizw\桌面\Programmers.xml";//文件名称与路径

             Stream fStream = new FileStream(fileName, FileMode.Create, FileAccess.ReadWrite);

             XmlSerializer xmlFormat = new XmlSerializer(

 typeof(List<Programmer>),

 new Type[] { typeof(Programmer),typeof(Person) }

 );//创建XML序列化器,需要指定对象的类型

             xmlFormat.Serialize(fStream, list);

             //使用XML反序列化对象

             fStream.Position = ;//重置流位置

             list.Clear();

             list = (List<Programmer>)xmlFormat.Deserialize(fStream);

             foreach (Programmer p in list)

             {

                 Console.WriteLine(p);

             }

             Console.Read();

         }

     }

(2)总结

使用XML序列化或反序列化时,需要对XML序列化器指定需要序列化对象的类型和其关联的类型。

XML序列化只能序列化对象的公有属性,并且要求对象有一个无参的构造方法,否者无法反序列化。

[Serializable]和[NonSerialized]特性对XML序列化无效!所以使用XML序列化时不需要对对象增加[Serializable]特性。

5.XML序列化对象详解

(1)说明

本节主要介绍:使用特性控制对象序列化成XML文件的格式。

(2)使用XmlElement(默认值)

类声明:

public class Person

    {

        [XmlElement]

        public string Name;//使用[XmlElement]特性

        public bool Sex;//默认使用了[XmlElement]特性

        public Person() { }//必须提供无参构造器,否则XmlSerializer将出错

    }

序列化生成的XML文件:

<Personxmlns:xsi="..."xmlns:xsd="...">
<Name>李志伟</Name>
<Sex>true</Sex>
</Person>

(3)使用XmlAttribute

类声明:

public class Person
{
[XmlElement]
public string Name;
[XmlAttribute]
public bool Sex;
public Person() { }//必须提供无参构造器,否则XmlSerializer将出错
}

序列化生成的XML文件:

<Personxmlns:xsi="..."xmlns:xsd="..."Sex="true">
<Name>李志伟</Name>
</Person>

(4)使用XmlText

类声明:

public class Person
{
[XmlText]
public string Name;
[XmlAttribute]
public bool Sex;
public Person() { }//必须提供无参构造器,否则XmlSerializer将出错
}

序列化生成的XML文件:

<Personxmlns:xsi="..."xmlns:xsd="..."Sex="true">李志伟</Person>

(5)使用XmlType和XmlAttribute(重命名节点名称)

类声明:

 [XmlType("个人信息")]
public class Person
{
[XmlAttribute("姓名")]
public string Name;
[XmlAttribute("性别")]
public bool Sex;
public Person() { }//必须提供无参构造器,否则XmlSerializer将出错
}

序列化生成的XML文件:

<个人信息xmlns:xsi="..."xmlns:xsd="..."姓名="李志伟"性别="true" />

(6)列表和数组的序列化

类声明:

[XmlType("个人信息")]

    public class Person

    {

        [XmlAttribute("姓名")]

        public string Name;

        [XmlAttribute("性别")]

        public bool Sex;

        public Person() { }//必须提供无参构造器,否则XmlSerializer将出错

    }

    class Program

    {

        static void Main(string[] args)

        {

            Person p = new Person();

            p.Name = "李志伟";

            p.Sex = true;

            Person[] ps = new Person[];

            ps[] = p;

            ps[] = p;

            ps[] = p;

            //使用XML序列化对象

            string fileName = @"D:\users\lizw\桌面\Programmers.xml";//文件名称与路径

            Stream fStream = new FileStream(fileName, FileMode.Create);

            XmlSerializer xmlFormat = new XmlSerializer(typeof(Person[]));

            xmlFormat.Serialize(fStream, ps);//序列化对象

            fStream.Dispose();//关闭文件

            Console.WriteLine("OK!");

            Console.Read();

        }

    }

序列化生成的XML文件:

<ArrayOf个人信息xmlns:xsi="..."xmlns:xsd="...">
<个人信息姓名="李志伟"性别="true" />
<个人信息姓名="李志伟"性别="true" />
<个人信息姓名="李志伟"性别="true" />
</ArrayOf个人信息>

注意:发现此时的XML文件的根节点名称变了。此时要重命名根节点应使用如下方式:

 [XmlType("个人信息")]

    public class Person

    {

        [XmlAttribute("姓名")]

        public string Name;

        [XmlAttribute("性别")]

        public bool Sex;

        public Person() { }//必须提供无参构造器,否则XmlSerializer将出错

    }

    [XmlType("人员信息")]

    public class PersonArray : List<Person> { }

    class Program

    {

        static void Main(string[] args)

        {

            Person p = new Person();

            p.Name = "李志伟";

            p.Sex = true;

            PersonArray ps = new PersonArray();

            ps.Add(p);

            ps.Add(p);

            ps.Add(p);

            //使用XML序列化对象

            string fileName = @"D:\users\lizw\桌面\Programmers.xml";//文件名称与路径

            Stream fStream = new FileStream(fileName, FileMode.Create);

            XmlSerializer xmlFormat = new XmlSerializer(typeof(PersonArray));

            xmlFormat.Serialize(fStream, ps);//序列化对象

            fStream.Dispose();//关闭文件

            Console.WriteLine("OK!");

            Console.Read();

        }

    }

序列化生成的XML文件:

<人员信息xmlns:xsi="..."xmlns:xsd="...">
<个人信息姓名="李志伟"性别="true" />
<个人信息姓名="李志伟"性别="true" />
<个人信息姓名="李志伟"性别="true" />
</人员信息>

(7)列表和数组的做为数据成员的序列化

类声明:

 [XmlType("信息")]

    public class Person

    {

        [XmlAttribute("姓名")]

        public string Name;

        [XmlAttribute("性别")]

        public bool Sex;

        public Person() { }//必须提供无参构造器,否则XmlSerializer将出错

    }

    public class PersonArray

    {

        public List<Person> Array=new List<Person>();

        public Person Person = new Person();

    }

    class Program

    {

        static void Main(string[] args)

        {

            PersonArray ps = new PersonArray();

            ps.Person = new Person();

            ps.Person.Name = "李志伟";

            ps.Person.Sex = true;

            ps.Array.Add(ps.Person);

            ps.Array.Add(ps.Person);

            ps.Array.Add(ps.Person);

            //使用XML序列化对象

            string fileName = @"D:\users\lizw\桌面\Programmers.xml";//文件名称与路径

            Stream fStream = new FileStream(fileName, FileMode.Create);

            XmlSerializer xmlFormat = new XmlSerializer(typeof(PersonArray));

            xmlFormat.Serialize(fStream, ps);//序列化对象

            fStream.Dispose();//关闭文件

            Console.WriteLine("OK!");

            Console.Read();

        }

    }

序列化生成的XML文件:

<PersonArrayxmlns:xsi="..."xmlns:xsd="...">
<Array>
<个人信息姓名="李志伟"性别="true" />
<个人信息姓名="李志伟"性别="true" />
<个人信息姓名="李志伟"性别="true" />
</Array>
<Person姓名="李志伟"性别="true" />
</PersonArray>

注意:假设这里需要为Array和Person的节点重命名,代码如下:

 [XmlType("信息")]

    public class Person

    {

        [XmlAttribute("姓名")]

        public string Name;

        [XmlAttribute("性别")]

        public bool Sex;

        public Person() { }//必须提供无参构造器,否则XmlSerializer将出错

    }

    public class PersonArray

    {

        [XmlArrayItem("个人信息")]

        [XmlArray("人员信息")]

        public List<Person> Array=new List<Person>();

        public Person Person = new Person();

    }

序列化生成的XML文件:

<PersonArrayxmlns:xsi="..."xmlns:xsd="...">
<人员信息>
<个人信息姓名="李志伟"性别="true" />
<个人信息姓名="李志伟"性别="true" />
<个人信息姓名="李志伟"性别="true" />
</人员信息>
<Person姓名="李志伟"性别="true" />
</PersonArray>

注意:把“人员信息”节点去掉呢(直接出现“个人信息”节点)

  [XmlType("信息")]

    public class Person

    {

        [XmlAttribute("姓名")]

        public string Name;

        [XmlAttribute("性别")]

        public bool Sex;

        public Person() { }//必须提供无参构造器,否则XmlSerializer将出错

    }

    public class PersonArray

    {

        [XmlElement("个人信息")]

        public List<Person> Array=new List<Person>();

        public Person Person = new Person();

    }

序列化生成的XML文件:

<PersonArrayxmlns:xsi="..."xmlns:xsd="...">

  <个人信息姓名="李志伟"性别="true" />

  <个人信息姓名="李志伟"性别="true" />

  <个人信息姓名="李志伟"性别="true" />

  <Person姓名="李志伟"性别="true" />

</PersonArray>

()类型继承与反序列化

类声明:

    public class Base { }

    [XmlType("信息A")]

    public class PersonA : Base

    {

        [XmlAttribute("姓名")]

        public string Name;

        [XmlAttribute("性别")]

        public bool Sex;

        public PersonA() { }//必须提供无参构造器,否则XmlSerializer将出错

    }

    [XmlType("信息B")]

    public class PersonB : Base

    {

        [XmlElement("姓名")]

        public string Name;

        [XmlElement("年龄")]

        public int Age;

        public PersonB() { }//必须提供无参构造器,否则XmlSerializer将出错

    }

    [XmlType("人员信息")]

    public class PersonArray

    {

        [XmlArrayItem(typeof(PersonA)), XmlArrayItem(typeof(PersonB))]

        public List<Base> ListPerson=new List<Base>();

    }

    class Program

    {

        static void Main(string[] args)

        {

            PersonA pa = new PersonA();

            pa.Name = "李志伟A";

            pa.Sex = true;

            PersonB pb = new PersonB();

            pb.Name = "李志伟B";

            pb.Age = ;

            PersonArray ps = new PersonArray();

            ps.ListPerson.Add(pa);

            ps.ListPerson.Add(pa);

            ps.ListPerson.Add(pb);

            ps.ListPerson.Add(pb);

            //使用XML序列化对象

            string fileName = @"D:\users\lizw\桌面\Programmers.xml";//文件名称与路径

            Stream fStream = new FileStream(fileName, FileMode.Create);

            XmlSerializer xmlFormat = new XmlSerializer(typeof(PersonArray));

            xmlFormat.Serialize(fStream, ps);//序列化对象

            fStream.Dispose();//关闭文件

            Console.WriteLine("OK!");

            Console.Read();

        }

    }

序列化生成的XML文件:

<人员信息xmlns:xsi="..."xmlns:xsd="...">
<ListPerson>
<信息A姓名="李志伟A"性别="true" />
<信息A姓名="李志伟A"性别="true" />
<信息B>
<姓名>李志伟B</姓名>
<年龄></年龄>
</信息B>
<信息B>
<姓名>李志伟B</姓名>
<年龄></年龄>
</信息B>
</ListPerson>
</人员信息>

意:同时为列表成员指定多个[XmlArrayItem(typeof(XXX))]可实现多种派生类型混在一起输出。

(9)排除不需要序列化的成员

类声明:

  public class Person
{
public string Name;
[XmlIgnore]// 这个属性将不会参与序列化
public bool Sex;
public Person() { }
}

序列化生成的XML文件:

<Personxmlns:xsi="..."xmlns:xsd="...">
<Name>李志伟</Name>
</Person>

(10)强制指定成员的序列化顺序

类声明:

 public class Person

    {

        [XmlElement(Order = )]

        public string Name;

        [XmlElement(Order = )]

        public bool Sex;

        public Person() { }//必须提供无参构造器,否则XmlSerializer将出错

    }

序列化生成的XML文件:

<Personxmlns:xsi="..."xmlns:xsd="...">
<Sex>true</Sex>
<Name>李志伟</Name>
</Person>

(11)自定义序列化行为

类声明:

 public class Person : IXmlSerializable

    {

        public string Name;

        public bool Sex;

        public Person() { }//必须提供无参构造器,否则XmlSerializer将出错

        public System.Xml.Schema.XmlSchema GetSchema()

        {

            return null;

        }

        public void ReadXml(System.Xml.XmlReader reader)

        {

            Name = reader.GetAttribute("姓名");

            Sex = reader.GetAttribute("性别").Equals("男") ? true : false;

        }

        public void WriteXml(System.Xml.XmlWriter writer)

        {

            writer.WriteAttributeString("姓名", Name);

            writer.WriteAttributeString("性别", Sex ? "男" : "女");

        }

    }

序列化生成的XML文件:

<Person姓名="李志伟"性别="男" />

(12)序列化设置XML命名空间

类声明:

[XmlRoot(Namespace = "http://msdn.microsoft.com/vsdh.xsd")]
public class Person
{
public string Name;
public bool Sex;
public Person() { }
}

序列化生成的XML文件:

<Personxmlns:xsi="..."xmlns:xsd="..."xmlns="http://msdn.microsoft.com/vsdh.xsd">
<Name>李志伟A</Name>
<Sex>true</Sex>
</Person>

(13)XML的使用建议

在服务端,C#代码中:

1. 建议不用使用低级别的XML API来使用XML,除非你是在设计框架或者通用类库。

2. 建议使用序列化、反序列化的方法来生成或者读取XML

3. 当需要考虑使用XML时,先不要想着XML结构,先应该定义好数据类型。

4. 列表节点不要使用[XmlElement],它会让所有子节点【升级】,显得结构混乱。

5. 如果希望序列化的XML长度小一点,可以采用[XmlAttribute],或者指定一个更短小的别名。

6. 不要在一个列表中输出不同的数据类型,这样的XML结构的可读性不好。

7. 尽量使用UTF-8编码,不要使用GB2312编码。

在客户端,JavaScript代码中,我不建议使用XML,而是建议使用JSON来代替XML,因为:

1. XML文本的长度比JSON要长,会占用更多的网络传输时间(毕竟数据保存在服务端,所以传输是免不了的)。

2. 在JavaScritp中使用XML比较麻烦(还有浏览器的兼容问题),反而各种浏览器对JSON有非常好的支持。

(14)反序列化的使用总结

如果XML是由类型序列化得到那的,那么反序列化的调用代码是很简单的,反之,如果要面对一个没有类型的XML,就需要我们先设计一个(或者一些)类型出来,这是一个逆向推导的过程,请参考以下步骤:

1. 首先要分析整个XML结构,定义与之匹配的类型,

2. 如果XML结构有嵌套层次,则需要定义多个类型与之匹配,

3. 定义具体类型(一个层级下的XML结构)时,请参考以下表格。

XML形式

处理方法

补充说明

XmlElement

定义一个属性

属性名与节点名字匹配

XmlAttribute

[XmlAttribute] 加到属性上

InnerText

[InnerText] 加到属性上

一个类型只能使用一次

节点重命名

根节点:[XmlType("testClass")] 
元素节点:[XmlElement("name")] 
属性节点:[XmlAttribute("id")] 
列表子元素节点:[XmlArrayItem("Detail")] 
列表元素自身:[XmlArray("Items")]

6.自定义序列化(仅适用于二进制与SOAP)

(1)自定义序列化的实现方式

可以通过在对象上实现 ISerializable 接口来自定义序列化过程。这一功能在反序列化后成员变量的值失效时尤其有用,但是需要为变量提供值以重建对象的完整状态。要实现ISerializable,需要实现 GetObjectData()方法以及一个特殊的构造函数,在反序列化对象时要用到此构造函数。

(2)示例程序   

[Serializable]

    public class Person : ISerializable

    {

        public string Name;

        public bool Sex;

        public Person() { }

        //必须的够着方法,反序列化时调用

        protected Person(SerializationInfo info, StreamingContext context)

        {

            Name = info.GetString("姓名");

            Sex = info.GetBoolean("性别");

        }

        //序列化时调用

        public void GetObjectData(SerializationInfo info, StreamingContext context)

        {

            info.AddValue("姓名", Name + "(自定义序列化)");

            info.AddValue("性别", Sex);

        }

        public override string ToString()

        {

            return "姓名:" + this.Name + "\t性别:" + (this.Sex ? "男" : "女");

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            Person p = new Person();

            p.Name = "李志伟A";

            p.Sex = true;

            //使用二进制序列化对象

            string fileName = @"D:\users\lizw\桌面\Programmers.xml";//文件名称与路径

            Stream fStream = new FileStream(fileName, FileMode.Create);

            BinaryFormatter binFormat = new BinaryFormatter();//创建二进制序列化器

            binFormat.Serialize(fStream, p);//序列化对象

            //使用二进制反序列化对象

            fStream.Position = ;//重置流位置

            p = (Person)binFormat.Deserialize(fStream);//反序列化对象

            Console.WriteLine(p);

            fStream.Dispose();//关闭文件

            Console.WriteLine("OK!");

            Console.Read();

        }

    }

注意:在序列化过程中调用 GetObjectData()时,需要填充方法调用中提供的SerializationInfo对象。只需按名称/值对的形式添加将要序列化的变量。其名称可以是任何文本。只要已序列化的数据足以在反序列化过程中还原对象,便可以自由选择添加至SerializationInfo 的成员变量。如果基对象实现了 ISerializable,则派生类应调用其基对象的 GetObjectData()方法。同样,在反序列化时也会调用含有(SerializationInfo info, StreamingContextcontext)参数的特殊的够着方法!否者将无法反序列化!!!

C# 序列化和反序列的更多相关文章

  1. Newtonsoft.Json序列化和反序列之javascriptConvert.SerializeObject,DeserializeObject,JsonWriter,JsonReader

    这里下载:http://www.newtonsoft.com/products/json/安装:   1.解压下载文件,得到Newtonsoft.Json.dll   2.在项目中添加引用.. jav ...

  2. (转)Newtonsoft.Json序列化和反序列

    这里下载:http://www.newtonsoft.com/products/json/安装:   1.解压下载文件,得到Newtonsoft.Json.dll   2.在项目中添加引用.. 序列化 ...

  3. python序列化与反序列

    python序列化与反序列 在python中提供了两个模块可进行序列化.分别是pickle和json.他们两者的功能都差不多,dumps和dump都是进行序列化,而loads和load则是反序列化. ...

  4. Newtonsoft.Json序列化和反序列

    这里下载:http://www.newtonsoft.com/products/json/安装:   1.解压下载文件,得到Newtonsoft.Json.dll   2.在项目中添加引用.. 序列化 ...

  5. Java 序列化 和 反序列--by Vincent

    序列化: Java 提供了一种把对象序列化的机制. 即把一个对象可以被表示为一个字节序列.然后可以写入文件保存. 字节序列包括:      该对象的数据.有关对象的类型的信息和存储在对象中数据的类型. ...

  6. 【leetcode-449】序列化和反序列化二叉搜索树

    序列化是将数据结构或对象转换为一系列位的过程,以便它可以存储在文件或内存缓冲区中,或通过网络连接链路传输,以便稍后在同一个或另一个计算机环境中重建. 设计一个算法来序列化和反序列化二叉搜索树. 对序列 ...

  7. Java实现 LeetCode 449 序列化和反序列化二叉搜索树

    449. 序列化和反序列化二叉搜索树 序列化是将数据结构或对象转换为一系列位的过程,以便它可以存储在文件或内存缓冲区中,或通过网络连接链路传输,以便稍后在同一个或另一个计算机环境中重建. 设计一个算法 ...

  8. 序列化与反序列化成XML

    http://blog.itpub.net/12639172/viewspace-490786/ 现在XML都普遍的用到了很多地方,它的平台无关.方便.结构化.适用性的特点让人不得不去接受它,在C#中 ...

  9. 使用 acl 库针对 C++ 对象进行序列化及反序列编程

    在开发网络应用程序时,各个模块之间的数据通信可谓是家常便饭,为了应对这些数据通信时数据交换的要求,程序员发明了各种数据格式:采用二进制数据结构(早期 C 程序员).采用 XML.采用SOAP(坑人的设 ...

  10. 关于json序列化和反序列的问题,没事写个案例,希望能帮到那些需要帮忙的朋友!

    现在关于json的读写问题,有许许多多的解决方法,因人而异,根据实际问题去选择自己想要的最容易方法.我觉得自带的Newtonsoft.Json是个不错的选择,随便写两个例子吧! 一:关于简单的json ...

随机推荐

  1. POP3、SMTP和IMAP之间的区别和联系

    POP3 POP3是Post Office Protocol 3的简称,即邮局协议的第3个版本,它规定怎样将个人计算机连接到Internet的邮件服务器和下载电子邮件的电子协议.它是因特网电子邮件的第 ...

  2. android ListView异步加载图片(双缓存)

    首先声明,参考博客地址:http://www.iteye.com/topic/685986 对于ListView,相信很多人都很熟悉,因为确实太常见了,所以,做的用户体验更好,就成了我们的追求... ...

  3. http实现发送post请求,获取结果集

    package com.ming; import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.Ou ...

  4. dll的加载方式主要分为两大类,显式和隐式链接

    之前简单写过如何创建lib和dll文件及简单的使用(http://blog.csdn.net/betabin/article/details/7239200).现在先再深入点写写dll的加载方式. d ...

  5. tar 解压命令

    1.tar.gz文件的解压 tar zxvf  *.tar.gz 2.bz2属性的解压 tar jxvf  *.bz2

  6. WordPress Platinum SEO插件跨站脚本漏洞

    漏洞名称: WordPress Platinum SEO插件跨站脚本漏洞 CNNVD编号: CNNVD-201309-398 发布时间: 2013-09-24 更新时间: 2013-09-24 危害等 ...

  7. (转载)Linux中cp直接覆盖不提示的方法

    (转载)http://soft.chinabyte.com/os/220/11760720.shtml 新做了服务器,cp覆盖时,无论加什么参数-f之类的还是提示是否覆盖,这在大量cp覆盖操作的时候是 ...

  8. Lua运算符

    + 加- 减* 乘/ 除^ 幂% 求余# 求长度= 赋值< 小于> 大于== 等于<= 不大于=> 不小于~= 不等于and 逻辑与or 逻辑或not 逻辑非.. 连接字符串

  9. HDU-1701 Binary Tree Traversals

    http://acm.hdu.edu.cn/showproblem.php?pid=1710 已知先序和中序遍历,求后序遍历二叉树. 思路:先递归建树的过程,后后序遍历. Binary Tree Tr ...

  10. 移动平台WEB前端开发技巧

    1.首先我们来看看webkit内核中的一些私有的meta标签,这些meta标签在开发webapp时起到非常重要的作用 <meta content="width=device-width ...