C#未能从程序集“mscorlib, Version=4.0.0.0, Culture=neutral, ……”中加载类型“……”。

出自： http://www.importnew.com/17964.html 序列化与反序列化 序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。一般将一个对象存储至一个储存媒介，例如档案或是记亿体缓冲等。在网络传输过程中，可以是字节或是XML等格式。而字节的或XML编码格式可以还原完全相等的对象。这个相反的过程又称为反序列化。 Java对象的序列化与反序列化 在Java中，我们可以通过多种方式来创建对象，并且只要对象没有被回收我们都可以复用该对象。但是，我们创建出来的这些Java对象都是存在于JVM的堆内存中的。只有JVM处于运行状态的时候，这些对象才可能存在。一旦JVM停止运行，这些对象的状态也就随之而丢失了。 但是在真实的应用场景中，我们需要将这些对象持久化下来，并且能够在需要的时候把对象重新读取出来。Java的对象序列化可以帮助我们实现该功能。 对象序列化机制（object serialization）是Java语言内建的一种对象持久化方式，通过对象序列化，可以把对象的状态保存为字节数组，并且可以在有需要的时候将这个字节数组通过反序列化的方式再转换成对象。对象序列化可以很容易的在JVM中的活动对象和字节数组（流）之间进行转换。 在Java中，对象的序列化与反序列化被广泛应用到RMI(远程方法调用)及网络传输中。

序列化（serialization）在计算机科学的数据处理中，是指将数据结构或对象状态转换成可取用格式（例如存成文件，存于缓冲，或经由网络中发送），以留待后续在相同或另一台计算机环境中，能恢复原先状态的过程。依照序列化格式重新获取字节的结果时，可以利用它来产生与原始对象相同语义的副本。对于许多对象，像是使用大量引用的复杂对象，这种序列化重建的过程并不容易。面向对象中的对象序列化，并不概括之前原始对象所关系的函数。这种过程也称为对象编组（marshalling）。从一系列字节提取数据结构的反向操作，是反序列化（也称为解编组、deserialization、unmarshalling）。 序列化在计算机科学中通常有以下定义: 序列化与反序列化为数据交换提供了可能，但是因为传递的是字节码，可读性差。在应用层开发过程中不易调试，为了解决这种问题，最直接的想法就是将对象的内容转换为字符串的形式进行传递。具体的传输格式可自行定义，但自定义格式有一个很大的问题——兼容性，如果引入其他系统的模块，就需要对数据格式进行转换，维护其他的系统时，还要先了解一下它的序列化方式。为了统一数据传输的格式，出现了几种数据交换协议，如：JSON, Protobuf，XML。这些数据交换协议可视为是应用层面的序列化/反序列化。 如前所述，序列化和反序列化的出现往往晦涩而隐蔽，与其他概念之间往往相互包容。为了更好了让大家理解序列化和反序列化的相关概念在每种协议里面的具体实现，我们将一个例子穿插在各种序列化协议讲解中。在该例子中，我们希望将一个用户信息在多个系统里面进行传递；在应用层，如果采用 .net 语言，所面对的类对象如下所示： JSON中的元素都是键值对——key:value形式，键值对之间以":"分隔，每个键需用双引号引起来，值的类型为String时也需要双引号。其中value的类型包括：对象，数组，值，每种类型具有不同的语法表示。 基础类型 对象 数组 说到XML就不得不介绍下SOAP（Simple Object Access protocol），SOAP 是一种被广泛应用的，基于 XML 为序列化和反序列化协议的结构化消息传递协议。SOAP 在互联网影响如此大，以至于我们给基于 SOAP 的解决方案一个特定的名称 --Web service。SOAP 虽然可以支持多种传输层协议，不过 SOAP 最常见的使用方式还是 XML+HTTP。SOAP 协议的主要接口描述语言（IDL）是 WSDL（Web Service Description Language）。SOAP 具有安全、可扩展、跨语言、跨平台并支持多种传输层协议。如果不考虑跨平台和跨语言的需求，XML 的在某些语言里面具有非常简单易用的序列化使用方法，无需 IDL 文件和第三方编译器 实际使用中具体要使用哪个协议，我们可以从上列出的几个特性进行综合考虑 序列化协议一方面要能摆脱语言、平台的束缚；另一方面要在业界耳熟能详应用广泛。比如Java标准的对象序列化实现就不是这一条的好榜样，你要一个C程序员将Java标准序列化实现的数据反序列化成对应结构体是一个很蛋疼的事情。相反，JSON就是一个很好的序列化协议，至少在这一条上算得上是佼佼者了。 序列化协议要能方便开发过程中的调试。做过二进制协议开发的同学一定深有体会，肉眼基本不可辨别序列化后的数据，需要借助一些第三方的工具一点点分析。相对于二进制协议，文本协议就比较和蔼可亲了。 协议要能够经得住时间的考验。一般情况下采用公开流行的协议是不存在这个问题的，因为他们都被成千上万的应用检验过了。特别要小心的是自定义协议，举个反例，比如自定义一个类似于Java标准序列化协议的协议，由于当前业务没有涉及到对象和对象之间的继承关系，所以协议制定者没有考虑对象继承的情况。但是随着业务的发展，系统中出现了继承关系的实体类，某个同事不小心将这种对象的实例序列化，结果可想而知。协议不够成熟，所以自定义协议需要考虑的因数很多。如果自己不是大牛，建议不要自定义序列化协议。 和稳定性差不多，满足通用性条件的协议基本不会出现这个问题。问题还是会出现在自定义协议上。协议的成熟是一个漫长的过程，要经过不断的测试。比如稳定性中出现的那个问题，协议将继承关系的序列化加入，升级之后就能解决问题。但是要做到兼容以前的版本就不那么容易了。协议的制定者也不是圣人，不可能考虑得那么周全，但是一定要有一套可扩展的方案，这样协议才能存活下来，慢慢迭代成稳定版本。 说道性能问题，无非就是时间和空间的博弈。序列化结果数据的大小，直接影响网络传输的带宽和磁盘存储的空间。序列化和反序列化过程所消耗的时间长短，影响系统的性能。几种常用的协议性能的比较网上有很多，这里就不详细介绍了。

楼主您好序列化就是用特定的流将对象持久化(将一个对象的属性写到内存，硬盘文件或者其他什么地方)的一个过程，用到的不多，好处？也没什么吧，就是你需要保存这个对象的时候用

序列化序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。序列化使其他代码可以查看或修改，那些不序列化便无法访问的对象实例数据。确切地说，代码执行序列化需要特殊的权限：即指定了 SerializationFormatter 标志的 SecurityPermission。在默认策略下，通过 Internet 下载的代码或 Internet 代码不会授予该权限；只有本地计算机上的代码才被授予该权限。通常，对象实例的所有字段都会被序列化，这意味着数据会被表示为实例的序列化数据。这样，能够解释该格式的代码有可能能够确定这些数据的值，而不依赖于该成员的可访问性。类似地，反序列化从序列化的表示形式中提取数据，并直接设置对象状态，这也与可访问性规则无关。对于任何可能包含重要的安全性数据的对象，如果可能，应该使该对象不可序列化。如果它必须为可序列化的，请尝试生成特定字段来保存不可序列化的重要数据。如果无法实现这一点，则应注意该数据会被公开给任何拥有序列化权限的代码，并确保不让任何恶意代码获得该权限。中文名序列化外文名Serialization类型概念类别通信快速导航技术Java编程中的序列化PHP目的1、以某种存储形式使自定义对象持久化；2、将对象从一个地方传递到另一个地方。3、使程序更具维护性。技术* 二进制序列化保持类型保真度，这对于在应用程序的不同调用之间保留对象的状态很有用。例如，通过将对象序列化到剪贴板，可在不同的应用程序之间共享对象。您可以将对象序列化到流、磁盘、内存和网络等等。远程处理使用序列化“通过值”在计算机或应用程序域之间传递对象。* XML 序列化仅序列化公共属性和字段，且不保持类型保真度。当您要提供或使用数据而不限制使用该数据的应用程序时，这一点是很有用的。由于 XML 是一个开放式标准，因此，对于通过 Web 共享数据而言，这是一个很好的选择。SOAP 同样是一个开放式标准，这使它也成为一个颇具吸引力的选择。Java编程中的序列化序列化的实现方法把一个Java对象写入到硬盘或者传输到网路上面的其它计算机，这时我们就需要自己去通过java把相应的对象写成转换成字节流。对于这种通用的操作，我们为什么不使用统一的格式呢？没错，这里就出现了java的序列化的概念。在Java的OutputStream类下面的子类ObjectOutputStream类就有对应的WriteObject(Object object) 其中要求对应的object实现了java的序列化的接口。在使用tomcat开发JavaEE相关项目的时候，我们关闭tomcat后，相应的session中的对象就存储在了硬盘上，如果我们想要在tomcat重启的时能够从tomcat上面读取对应session中的内容，那么保存在session中的内容就必须实现相关的序列化操作，还有jdbc加载驱动用的就是反序列化，将字符串变为对象。

序列化 (Serialization）是将对象的状态信息转换为可以存储或传输的形式的过程。数据序列化用于模块通讯时，将对象序列化为通信流，高效的传输到另一个模块，并提供反序列化还原数据。对于大数据传输场景下序列化的性能、大小也直接影响了数据传输的性能。

* 二进制序列化保持类型保真度，这对于在应用程序的不同调用之间保留对象的状态很有用。例如，通过将对象序列化到剪贴板，可在不同的应用程序之间共享对象。您可以将对象序列化到流、磁盘、内存和网络等等。远程处理使用序列化“通过值”在计算机或应用程序域之间传递对象。* XML 序列化仅序列化公共属性和字段，且不保持类型保真度。当您要提供或使用数据而不限制使用该数据的应用程序时，这一点是很有用的。由于 XML 是一个开放式标准，因此，对于通过 Web 共享数据而言，这是一个很好的选择。SOAP 同样是一个开放式标准，这使它也成为一个颇具吸引力的选择。

【答案】：Java提供了一种叫做对象序列化的机制，他把对象表示成一连串的字节，里面包含了对象的数据，对象的类型信息，对象内部的数据的类型信息等等。因此，序列化可以看成是为了把对象存储在磁盘上或者是从磁盘上读出来并重建对象而把对象扁平化的一种方式。反序列化是把对象从扁平状态转化成活动对象的相反的步骤。

序列化（Serialization）是.NET平台最酷的特性之一。1、为什么要序列化：首先你应该明白系列化的目的就不难理解他了。系列化的目的就是能在网络上传输对象，否则就无法实现面向对象的分布式计算。比如你的客户端要调用服务器上的一个方法获得一个产品对象，比如方法为：public Product findProduct(int product_id); 注意该方法返回一个Product对象，如果没有系列化技术，客户端就收不到返回的对象Product。而序列化的实现就是把对象变成一个可在网络上传输的字节流。2、利用序列化技术，可以实现对象的备份和还原。序列化可以将内存中的对象（或对象图）序列化为数据流，并保存到磁盘上进行持久化；还可以将数据流反序列化为对象，实现对象的还原。序列化技术在分布式系统的数据传输中得到充分的利用，如：XML Web Service 利用XML序列化实现跨平台，.NET Remoting 则用到了二进制序列化和SOAP序列化。.NET Compact Framework 2.0 支持XML序列化，不支持二进制序列化和SOAP序列化。而 .NET Compact Framework 1.0 连XML序列化都不支持。不过 OpenNETCF 1.x 为 .NET CF 1.0 实现了一个XML序列化的类，这个类在 OpenNETCF.Xml.dll 程序集中可以找到。序列化和反序列化用于将一个对象保存到文件，和从文件读取。 using System.IO; using System.Runtime.Serialization.Formatters.Binary; [Serializable()]//可以序列化的类需要用这个属性标记 public class ToBeSerialized { public int a; public string b; public ToBeSerialized(int a,string b) { this.a=a; this.b=b; } } public class Test { public void Serialize()//序列化 { ToBeSerialized tbs = new ToBeSerialized(22,"SOM"); Stream fs = File.Create("Serialized.txt"); BinaryFormatter serializer = new BinaryFormatter(); serializer.Serialize(fs, tbs); fs.Close(); } public void DeSerialize()//反序列化 { ToBeSerialized restore; Stream fs = File.OpenRead("Serialized.txt"); BinaryFormatter deserializer = new BinaryFormatter(); restore = (ToBeSerialized)(deserializer.Deserialize(fs));//反序列化得到的对象 fs.Close(); } }

at weblogic.servlet.internal.session.SessionData.getAttribute(SessionDat

查看《U8常见问题快查手册》，关于IIS一节，内有详细的介绍，本例尝试方案为：32.system.runtime.serialization.serialzationexprction。输入流是无效的二进制格式。开始内容(以字节为单位)是: 3C-68-74-6D-6C-3E-0D-0A-20-20-20-20-3C-68-65-61-64...”。 建议方案：请检查IIS中的虚拟目录u8applicationEX 是否丢失，如没有请手工增加。

将数据序列化有什么作用啊？ 啊？序列化？应该是说一个数据结构，比如二叉树之类，序列化以后会变成一个char数组或者一个string字符串这样，方便你存到文件里面或者通过网络传输。然后要恢复的时候就是“反序列化”，把文件里读出来/从网络收到的char数组或者string恢复成一棵二叉树或者其他什么东西。 主要就是方便保存 Java中如何实现序列化，有什么意义？ 序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决对象流读写操作时可能引发的问题（如果不进行序列化可能会存在数据乱序的问题）。 要实现序列化，需要让一个类实现Serializable接口，该接口是一个标识性接口，标注该类对象是可被序列化的，然后使用一个输出流来构造一个对象输出流并通过writeObject(Object)方法就可以将实现对象写出（即保存其状态）；如果需要反序列化则可以用一个输入流建立对象输入流，然后通过readObject方法从流中读取对象。序列化除了能够实现对象的持久化之外，还能够用于对象的深度克隆。java 中的序列化是什么意思？有什么好处 序列化 (Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。 序列化是针对自定义类型或者零散数据，好处就是让数据方便存储和传输（传递），你可以理解为将零散的字母变成一个字符串（当然实际序列化过程并不是这么简单），可以统一存储和传输，而标准序列化传递后，还可以依次读取出来。 序列化的目的是标准化和可存储，通常用于数据库、文件操作以及和系统标准化函数进行通信。 序列化的作用 Object serialization 允许你将实现了Serializable接口的对象转换为字节序列，这些字节序列可以被完全存储以备以后重新生成原来的对象。 举个例子： 网络传输的时候，可以传字符串，亦可以传对象object，例如socket，传字符串的时候接收方很容易解析出来，但是，传一个对象的时候，对方读完字节流后，不知道你传的什么对象，所以没办法给转成原来的对象并解析对象的属性，这时候就要用到序列化和反序列化。 类实现序列化接口，socket发送这个对象的字节流，接收方到流后就可以将流反序列化成对象，然后使用对象的方法和属性。 --这里只讲了一个网络传输方面的应用，其实还有很多作用的，可以自己研究下 java序列化的作用 简单的说序列化就是以某种方式将内存中的Java对象编程2进制字节 既然是字节，那么处理起来就很方便，可以存储起来，也可以存在文件中、或者发送给别人。 Java平台允许我们在内存中创建可复用的Java对象，但一般情况下，只有当JVM处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比JVM的生命周期更长（即每个对象都在JVM中） 但在现实应用中，就可能要停止JVM运行，但有要保存某些指定的对象，并在将来重新读取被保存的对象。这是Java对象序列化就能够实现该功能。（可选择入数据库、或文件的形式保存） 但是有时候，是需要在网络上传输某些对象，如当使用RMI(远程方法调用)，也需要用到序列化和反序列化 亲，如果回答满意，亲即时采纳，你的理解是我回答的动力，谢谢！！！ C#中的对象序列化是什么意思?序列化有什么好处?又有什么具体的应用?? 序列化就是把一个对象保存到一个文件或数据库字段中去，反序列化就是在适当的时候把这个文件再转化成原来的对象使用。 我想最主要的作用有： 1、在进程下次启动时读取上次保存的对象的信息 2、在不同的AppDomain或进程之间传递数据 3、在分布式应用系统中传递数据 序列化的作用是什么呀· 序列化是什么： 序列化就是将一个对象的状态（各个属性量）保存起来，然后在适当的时候再获得。 序列化分为两大部分：序列化和反序列化。 C#序列化和反序列化到底是什么意思？ 序列化就是把一个对象保存到一个文件或数据库字段中去，反序列化就是在适当的时候把这个文件再转化成原来的对象使用。 我想最主要的作龚有： 1、在进程下次启动时读取上次保存的对象的信息 2、在不同的AppDomain或进程之间传递数据 3、在分布式应用系统中传递数据 Java中对象序列化的作用是什么？全面一点，谢谢 1、序列化是干什么的？ 简单说就是为了保存在内存中的各种对象的状态，并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保存Object States，但是Java给你提供一种应该比你自己好的保存对象状态的机制,那就是序列化。 2、什么情况下需要序列化 a）当你想把的内存中的对象保存到一个文件中或者数据库中时候； b）当你想用套接字在网络上传送对象的时候； c）当你想通过RMI传输对象的时候； 3、当对一个对象实现序列化时，究竟发生了什么？ 在没有序列化前，每个保存在堆（Heap）中的对象都有相应的状态（state），即实例变量（instance ariable）比如： Foo myFoo = new Foo(); myFoo .setWidth(37); myFoo.setHeight(70); 当通过下面的代码序列化之后，MyFoo对象中的width和Height实例变量的值（37，70）都被保存到foo.ser文件中，这样以后又可以把它 从文件中读出来，重新在堆中创建原来的对象。当然保存时候不仅仅是保存对象的实例变量的值，JVM还要保存一些小量信息，比如类的类型等以便恢复原来的对 象。 FileOutputStream fs = new FileOutputStream("foo.ser"); ObjectOutputStream os = new ObjectOutputStream(fs); os.writeObject(myFoo); 4、实现序列化（保存到一个文件）的步骤 a）Make a FileOutputStream java 代码 FileOutputStream fs = new FileOutputStream("foo.ser"); b）Make a ObjectOutputStream java 代码 ObjectOutputStream os = new ObjectOutputStream(fs); c）write the object java 代码 os.writeObject(myObject1); os.writeObject(myObject2); os.writeObject(myObject3); d) close the ObjectOutputStream java 代码 os.close(); 5、举例说明 java 代码 import java.io.*; public class Box implements Serializable { private int width; private int height; public void setWidth(int width){ this.width = width; } public void setHeight(int height){ this.height = height; } public static void main(String[] args){ Box myBox = new Box(); myBox.setWidth(50); myBox.setHeight(30); try{ FileOutputStream fs = new FileOutputStream("foo.ser"); ObjectOutputStream os ...... Java中序列化作用是什么？为什么要序列化？ 序列化是可以讲对象长期保存在硬盘上，或通过网络传递给远端，可以序列化的对象要实现Serializable接口，此接口中没有方法，是一个标志，说明实现此接口的类可以启动并使用系列化功能； 序列化本质上是将对象解析成二进制流，并且实现Serializable接口的子类都有序列化功能；

那表示可序列化，这个接口表示接收int,Long,（还有一个类型我忘记了），的类型数据

java序列化中如果要标记为不可序列化的字段，可以使用关键字：tranisant修饰。Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。

序列化是用来通信的，服务端把数据序列化，发送到客户端，客户端把接收到的数据反序列化后对数据进行操作，完成后再序列化发送到服务端，服务端再反序列化数据后对数据进行操作。序列化的方法，就我知道的有三种： （1）二进制序列化【二进制序列化是通过BinaryFormatter类来实现的，这个类位于System.Runtime.Serialization.Formatters.Binary命名空间下。】 （2）XML序列化 【XML序列化是通过XmlSerializer 类来实现的， 这个类位于System.Xml.Serialization命名空间下。】 （3）SOAP序列化【SOAP序列化是通过SoapFormatter类来实现的，这个类位于System.Runtime.Serialization.Formatters.Soap命名空间下，并且需要注意需要手动添加对这个命名空间的引用---这么久了还没采纳

这是一个序列化器，用来将对象序列化为可以通过SOAP传输的字符串。一般用来在使用SOAP协议连接的服务器端和客户端之间传输对象数据时进行压缩（对象-SOAP）和解压缩（SOAP-对象）。

kafka producer序列化数据的时候遇到错误 org.apache.kafka.common.errors.SerializationException: Can"t convert value of class com.google.protobuf.LiteralByteString to class org.apache.kafka.common.serialization.StringSerializer specified in value.serializer Driver stacktrace: 要检查下参数设置 要注意不同版本的API也不一样

书上原话： 当要将一个对象存储在网络、硬盘、或通过流传输的时候，必须对该类实现序列化，否则不能执行以上操作！百度词条：JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API没有直接的联系。通过序列化可以将对象以字节流的形式存储在文件或者数据库中应该就是你想问的吧。基础了解下试试做个例子应该就能理解了祝你好运~

在 System.ComponentModel.Design.Serialization.CodeDomSerializerBase.Error(IDesignerSerializationManager manager, String exceptionText, String helpLink) 在 System.ComponentModel.Design.Serialization.CodeDomSerializerBase.DeserializeAssignStatement(IDesignerSerializationManager manager, CodeAssignStatement statement) 在 System.ComponentModel.Design.Serialization.CodeDomSerializerBase.DeserializeStatement(IDesignerSerializationManager manager, CodeStatement statement)

类中影响Serialization进程的特征，两边的操作使用的类版本不同，但它们的 serialVersionUID 必须是一样的。它是用来识别两边的类是否兼容的，两边不同时不应该继续还原状态，而是应该停止下来，因为有人把事情搞错了。如果你的类没有实现 java.io.Serializable 或 java.io.Externalizable，这个字段则没有意义。如果你没听说过 Java Serialization (序列化，有人书翻译成串行化），那去找些 serialization 介绍看看，下面说的第2段类结构变化时是中级水平的，理解 Java 的一些细节才能理解，多数情况下人们只提到第一种情况(类的结构没有变化时)，也只需要第一种情况。当Serialization两端(比如Socket两端)使用一个类的不同版本时，我们必须提供 serialVersionUID，它可以用JDK自带的 serialver 命令行来计算:private static final long serialVersionUID = xxxx ;如果类中出现了下面两个方法，那么将会被用到，否则使用默认的实现:private void readObject(ObjectInputStream) throws IOException,ClassNotFoundException;private void writeObject(ObjectOutputStream)throws IOException;记住这里出现的方法和字段都是 private.新版本中仅增加了字段或方法而没有改变旧版本中已有的东西时，我们只要保证两个版本中的 serialVersionUID 是一样的就行了.具体样例可以看 JDK 源码中的像 ArrayList 这些类的代码的 readObject 和 writeObject 方法。类的结构有些变化时,新版本对旧版本中某些东西进行了删减时, Field 的变化我们需要在readObject和writeObject方法中进行处理ObjectOutputStream.PutField 类可达到这个目的只是保证两个版本中的 serialVersionUID 一致是行不通的类中必需两个常量：private static final long serialVersionUID;private static final ObjectStreamField[] serialPersistentFields下面样例是当客户端和服务端使用的类的版本不同并且类的结构也改变了，比如：12345678910111213 对方使用的类 Entry 是：public class Entry12 ... { private String name, email; private static final long serialVersionUID = 12L;}现在我们改变了类的设计了：public class Entry12 ... { private EntryInternal basic; private static final long serialVersionUID = 12L; private class EntryInternal { private String name, email; }}/* 这是一段代码片段，我们假设新版本的类 name & email 两个字段进行了修改 * (这里我们放到一个内部类EntryInternal 中),而旧版本中直接属于这个类. * * 请注意这里的字段和方法的签名, 它们都是 private 的或者是常量. */public class Entry12 implements Serializable { private EntryInternal pair = new EntryInternal(); /* 这是必要的，因为版本不同 */ private static final long serialVersionUID = 12L; ** 这也是必要的，否则写 putFields 时会抛出异常. * This field will be used by {@link #writeObject(ObjectOutputStream)}, * if this field is missing, follwing exception will be threw when invoke * {@link java.io.ObjectOutputStream.PutField#put(String,)} : * an exception ‘java.lang.IllegalArgumentException: No such object field" will be threw. */ private static final ObjectStreamField[] serialPersistentFields = new ObjectStreamField[] { new ObjectStreamField("name" , String.class),// new ObjectStreamField("email" , String.class),// }; /* 我们在这里不是直接写出字段，而把要写出的字段包装起来， 我们按需交换字段，而不是直接读写pair 这个字段. */ private void readObject(ObjectInputStream input) throws IOException, ClassNotFoundException { ObjectInputStream.GetField getFields = input.readFields(); /* 请注意：使用 Serializable 进行交换时不使用构造方法，所以这时 pair 还未初始化. */ pair = new EntryInternal(); pair.name = (String) getFields.get("name", null); pair.email = (String) getFields.get("email", null); } /* 写出时跟读入时一样 */ private void writeObject(ObjectOutputStream output) throws IOException { ObjectOutputStream.PutField putFields = output.putFields(); putFields.put("name", pair == null ? null : pair.name); putFields.put("email", pair == null ? null : pair.email); output.writeFields(); } ….. }

序列化是将类型，如people类，转换为二进制编码的字节数组。便于在网络中传输。通常是在通信，或者WCF中使用，使用起来非常简单，也可以序列化为XML，在网络中传输

创建的一个window窗体程序，需要引用到System.Web.Script.Serialization。习惯在解决方案右键添加引用，发现添加应用窗口没有“System.Web.Script.Serialization”。经查，这个引用是在一个叫“System.Web.Extensions.dll”的dll里面。在C盘（.net安装目录）搜索“System.Web.Extensions.dll”，找到这个dll，在通过“浏览”方式，找到该DLL引用后，发现它出现一个叹号。折腾了老半天，注意到错误提示中说了当前所用的框架是“.Net Framework 4 Client Profile”，看来这是VS 2010里新出来的划分了（在之前的版本，可是没有“Client”这东东的），于是打开项目的属性页，将“应用程序”下的“目标框架”选为“.Net Framework 4”。这样解决了问题。

竟然问到我。我知道的都告诉你吧，序列化这东西我也没做过，不过对于你的问题我还是能答个大概，过后自己找下资料吧#include "stdafx.h"#include <fstream>#include <boost/serialization/vector.hpp>#include <boost/archive/xml_oarchive.hpp>#include <boost/archive/xml_iarchive.hpp>#pragma comment(lib,"C://libboost_serialization-vc80-mt-gd-1_45.lib")//////////////////////////////////////////////////////////////////////////////// class subtest//类声明{public: subtest()//构造函数: mvalue1(-1)//成员变量初始化{}template< class archive >//这是类模板，学过C++的都应该知道的吧，接下来就以archive当做一个类型用，看来面这个函数serialize()void serialize( archive &ar , unsigned int filever )//参数一个是模板类，前面声明了，具体是什么类型看调用时的情况。{ar & BOOST_SERIALIZATION_NVP(mvalue1);//按位与操作。BOOST_SERIALIZATION_NVP是一个宏，XML下生成对应名称。ar & BOOST_SERIALIZATION_NVP(nvalue1);//}int mvalue1; //double nvalue1;//两个类的公有成员。};////////////////////////////////////////////////////////////////////////////////class test{public: test(): mvalue(-1){}template< class archive >void serialize( archive &ar , unsigned int filever ){ar & BOOST_SERIALIZATION_NVP(mvalue);ar & BOOST_SERIALIZATION_NVP(nvalue);ar & BOOST_SERIALIZATION_NVP(obj);}int mvalue; double nvalue;subtest obj;};////////////////////////////////////////////////////////////////////////////////int _tmain(int argc, _TCHAR* argv[]){/*** save archive */{std::vector< int > ints;test* a = new test;//创建一个test这个类的实例ints.push_back( 100 );//这部分内容你可以看C++primer.这是在容器尾添加值为100的元素ints.push_back( 200 );std::ofstream ofs("c://test.xml");//把生成的xml文件存到这个路径下面boost::archive::xml_oarchive oa(ofs);int nvalue = 106; a->nvalue = 0.1111;//成员变量赋值a->obj.mvalue1=123;a->obj.nvalue1=0.222;oa << BOOST_SERIALIZATION_NVP(nvalue); //输出。整个程序以模板的形式载入XML文档，然后按位与保存。 再多的我也不回答你了，因为我也没做过这些oa << BOOST_SERIALIZATION_NVP(ints);oa << BOOST_SERIALIZATION_NVP(a);delete a;}/*** load from archive */{std::vector< int > ints;std::ifstream ofs("c://test.xml");boost::archive::xml_iarchive oa(ofs);int nvalue = 0; test* a = NULL; oa >> BOOST_SERIALIZATION_NVP(nvalue); oa >> BOOST_SERIALIZATION_NVP(ints);oa >> BOOST_SERIALIZATION_NVP(a);for( std::vector< int >::iterator i = ints.begin() ; i != ints.end() ; i++ ){printf("the value of vector %d ",*i);}}return 0;}

应该是在输入"true"，输入错，输入成："trad"了；

[Serializable()]class MyClass{ public string a;}

、Binary方法进行序列化1、首先。你被序列化的类需要用[Serializable]特性修饰，例如：[Serializable]public class AA{public int i = 5;}2、那么你可以用如下方法序列化和反序列化：/// <summary> /// 序列化为二进制字节数组 /// </summary> /// <param name="request">要序列化的对象 </param> /// <returns>字节数组 </returns> public static byte[] SerializeBinary<T>(T request){System.Runtime.Serialization.Formatters.Binary.BinaryFormatter serializer = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();System.IO.MemoryStream memStream = new System.IO.MemoryStream();serializer.Serialize(memStream, request);return memStream.GetBuffer();}/// <summary> /// 从二进制数组反序列化得到对象 /// </summary> /// <param name="buf">字节数组 </param> /// <returns>得到的对象 </returns> public static T DeserializeBinary<T>(byte[] buf){System.IO.MemoryStream memStream = new MemoryStream(buf);memStream.Position = 0;System.Runtime.Serialization.Formatters.Binary.BinaryFormatter deserializer =new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();T newobj = (T)deserializer.Deserialize(memStream);memStream.Close();return newobj;}3、调用方法AA p = new AA(); p.i = 15; byte[] bytes = SerializeBinary<AA>(p); AA p2 = DeserializeBinary<AA>(bytes); 二、XML序列化using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Xml.Serialization;using System.IO;namespace RegexActivator{public class ExtendMethods{public static void Serial<T>(T[] items, string path){XmlSerializer xmlSerializer = new XmlSerializer(typeof(T[]));TextWriter writer = new StreamWriter(path);try{xmlSerializer.Serialize(writer, items);}finally{writer.Close();}}public static T[] Deserial<T>(string path){if (!File.Exists(path)) return new T[0];XmlSerializer xmlSerializer = new XmlSerializer(typeof(T[]));FileStream fs = new FileStream(path, FileMode.Open);T[] items;try{items = (T[])xmlSerializer.Deserialize(fs);}finally{fs.Close();}return items;}}}

说序列化Json字符串吧命名空间：System.Web.Script.Serialization引用：System.Web.Extensions.dll, 类名：JavaScriptSerializer序列化：public void Serialize(object obj, StringBuilder output);public string Serialize(object obj);反序列化：public T Deserialize(string input);public object Deserialize(string input, Type targetType);public object DeserializeObject(string input);

VS2005默认打开03的sln时会提示运行工程移植向导的。

声明的时候加上 transient 这个关键字就可以了

var a=new {ID=1,Name="name",OtherInfo="other"};string strJson=new JavaScriptSerializer().Serialize(a);需要添加System.Web.Extensions.dll库文件引用需要引用System.Web.Script.Serialization命名空间

锁的类型： 基本的封锁类型有两种： 排它锁(X锁) 和 共享锁(S锁) X锁，是事务T对数据A加上X锁时，只允许事务T读取和修改数据A S锁，是事务T对数据A加上S锁时，其他事务只能再对数据A加S锁，而不能加X锁，直到T释放A上的S锁。 若事务T对数据对象A加了S锁，则T就可以对A进行读取，但不能进行更新(S锁因此又称为读锁)。在T释放A上的S锁以前，其他事务可以再对A加S锁，但不能加X锁，从而可以读取A，但不能更新A。 更多锁的类型和隔离级别参考 SQL 隔离级别 丢失更新（一类丢失更新） 撤销一个事务时，把其他事务已提交的更新数据覆盖 脏读 一个事务读到另一个事务未提交的更新数据 不可重复读 一个事务读到另一个事务已提交的更新数据 覆盖更新（二类丢失更新） 这是不可重复读中的特例，一个事务覆盖另一个事务已提交的更新数据 虚读（幻读） 一个事务读到另一个事务已提交的新插入的数据 在运用X锁和S锁对数据对象加锁时，还需要约定一些规则。例如何时申请X锁或S锁、持锁时间、何时释放等。称这些规则为封锁协议（Locking Protocol） 一级封锁协议（对应read uncommited） 事务T在修改数据R之前必须先对其加X锁，直到事务结束才释放，事务结束包括正常结束（COMMIT）和非正常结束（ROLLBACK）。 一级封锁协议可以 防止丢失修改 ，并保证事务T是可恢复的。使用一级封锁协议可以解决丢失修改问题。 在一级封锁协议中，如果 仅仅是读数据不对其进行修改，是不需要加锁的 ，它 不能保证可重复读和不读“脏”数据 。 二级封锁协议（对应read commited） 在一级封锁协议之上，事务T在读取数据R之前必须先对其加S锁，读完后方可释放S锁。 二级封锁协议除防止了丢失修改，还可以 进一步防止读“脏”数据 。 但在二级封锁协议中，由于读完数据后即可释放S锁，所以它 不能保证可重复读 。 三级封锁协议（对应reapetable read） 在一级封锁协议之上，事务T在读取数据R之前必须先对其加S锁，直到事务结束才释放S锁。 三级封锁协议除防止了丢失修改和不读“脏”数据外，还 进一步防止了不可重复读 。 四级封锁协议（对应serialization） 四级封锁协议是对三级封锁协议的增强，其实现机制也最为简单，直接对事务中所读取或者更改的数据所在的表 加表锁 ，也就是说，其他事务不能读写该表中的任何数据。这样五类并发问题都得以避免！

这是编译前引用到的dll找不到，原因是软件冲突或者安装出错。MSDN上有老外说这是一个bug，你可以在vs上新建工程再编译，这时不会报错。如果一定要在命令提示符下运行，则采用：csc /noconfig *.cs问题就解决了。

通常在需要序列化属性下标记即可：[JsonProperty(Name="password")]publicstringPassword{get;set;}你试试不标记的情况下能否实现~

反射和序列化是不同的。反射:程序集包含模块，而模块包含类型，类型又包含成员。反射则提供了封装程序集、模块和类型的对象。您可以使用反射动态地创建类型的实例，将类型绑定到现有对象，或从现有对象中获取类型。然后，可以调用类型的方法或访问其字段和属性 序列化:序列化是将对象转换为容易传输的格式的过程。例如，可以序列化一个对象，然后使用 HTTP 通过 Internet 在客户端和服务器之间传输该对象。在另一端，反序列化将从该流重新构造对象。 　　　　

System.Web.Script.Serialization .net 自带的json操作类，位于3.0以上的System.Web.Extensions类库中

不太清楚，一般我都是代码中有异常才会出现这种错误帮你顶下吧

int[][] arr = new int[2][]; arr[0] = new int[] { 1, 2, 3, 4 }; arr[1] = new int[] { 11, 22, 33, 44 }; System.Web.Script.Serialization.JavaScriptSerializer jsSeria = new System.Web.Script.Serialization.JavaScriptSerializer(); string s = jsSeria.Serialize(arr); //序列化 int[][] arr2 = jsSeria.Deserialize(s, typeof(int[][])) as int[][];//反序列化

直接把这个包复制到wevbbroot下的lib文件夹下

Image

用处就是以文本(二进制/XML)的形式保存/传递你对象的状态了，这样就可以在下次或者在别的地方(互联网上的另一个程序)读取这些文本(二进制/XML)以还原对象的状态。

选b。其他错误是序列化通常有二进制和xml两种对应该是System.Runtime.Serialization或者System.Xml.Serialization在类和属性上定义就可以了

首先,这个做法应该说不是标准的,序列化的前提,就是要相同类进行序列化与反序列化.但是你所提的需求在某些特殊的场合,的确会碰到,我这里有一个变通的做法,采用 XmlSeriliazer 序列化成xml,在另一端反序列化回来。通过XML，取出类和命名空间的指定。

　　Java 序列化 serialization主要职责就是将一个对象的状态转化为一个字节序列，以方便对象的持久化或网络传输。反序列化的过程正好相反。开发人员所要做的只是实现Serializable接口，然后调用ObjectOutputStream/ObjectInputStream的WriteObject/ReadObject方法即可，其他的工作 JVM　会自动帮你做了。　　那通过实现Serializable 接口所获取的序列化能力是否有安全隐患？由于这些字节序列已经脱离了Java的安全体系存在于磁盘或网络上，我们能否对序列化后的字节序列进行查看和修改，甚至于注入恶意病毒呢？ Java 反序列化机制是否又会对建立的对象进行验证以确保它的安全性、准确性呢？ 如果你想到这些问题，那恐怕答案会让你失望了。Java序列化后的字节序列基本都是明文存在的，而且字节序列的组成有很明确的文档进行说明，你可以试着用一些十六进制的文本编辑工具，如Hexeditor 查看一下对象序列化后的内容，你都能看到很多私有变量的实际赋值。关于字节序列的说明，可参考对象序列化流协议 ,这里就不多说了。这篇文章的重点是说一些Java提供的安全机制，通过这些机制，我们能够提升序列化/反序列化的安全指数。

对象持久化(Persistence)对象持久化就是将对象存储在可持久保存的存储介质上，例如主流的关系数据库中。在实际应用中，需要将业务数据以对象的方式保存在数据库中，就需要应用到相应的对象持久化框架，如现在广为认知的Hibernate。而如果查阅对象持久化的历史，你会发现早在1970年就已经开始有称之为面向对象数据库OODBMS。通常这些面向对象的数据库和特定的一种语言绑定。对象持久化的重点在于如何将业务数据对象存储在持久化介质上，并同时提供查询修改的手段。数据序列化(Serialization)数据序列化就是将对象或者数据结构转化成特定的格式，使其可在网络中传输，或者可存储在内存或者文件中。反序列化则是相反的操作，将对象从序列化数据中还原出来。而对象序列化后的数据格式可以是二进制，可以是XML，也可以是JSON等任何格式。对象/数据序列化的重点在于数据的交换和传输，例如在远程调用技术(如EJB,XML-RPC, Web Service)，或者在GUI控件开发(JavaBean)等等。总结一下，对象持久化和对象序列化是两个完全不同的应用场景，尽管你也可以说将一个对象序列化后存储在数据库中，但是你也不能说是对象持久化。

JavaScriptSerializer 类由异步通信层内部使用，用于序列化和反序列化在浏览器和 Web 服务器之间传递的数据。您无法访问序列化程序的此实例。但是，此类公开了公共 API。因此，当您希望在托管代码中使用 JavaScript 对象符号 (JSON) 时可以使用此类。若要序列化对象，请使用 Serialize 方法。若要反序列化 JSON 字符串，请使用 Deserialize 或 DeserializeObject 方法。若要序列化和反序列化 JavaScriptSerializer 本身不支持的类型，请使用 JavaScriptConverter 类来实现自定义转换器。然后，使用 RegisterConverters 方法注册转换器。托管类型和 JSON 之间的映射下表显示序列化进程中托管类型和 JSON 之间的映射。JavaScriptSerializer 本身支持这些托管类型。将 JSON 字符串反序列化为托管类型时，采用相同的映射。但是，反序列化可能是非对称的，并非所有可序列化的托管类型都可以从 JSON 反序列化得到。二、通过JavaScriptSerializer来实现。它的名字空间为：System.Web.Script.Serialization如果要使用它，还须添加System.Web.Extensions库文件引用参考实体类：Customerpublic class Customer{public int Unid { get; set; }public string CustomerName { get; set; }}类JavaScriptSerializer描述：为启用 AFAX 的应用程序提供序列化和反序列化功能。（一） 序列化方法：public string Serialize(Object obj)，用于将对象转换为 JSON 字符串public string ScriptSerialize(Customer customer){JavaScriptSerializer js = new JavaScriptSerializer();return js.Serialize(customer);}测试：Customer cc = new Customer { Unid = 1, CustomerName = "John" };string strJson = ScriptSerialize(cc);Console.WriteLine(strJson);（二）反序列化public Customer ScriptDeserialize(string strJson){JavaScriptSerializer js = new JavaScriptSerializer();return js.Deserialize<Customer>(strJson);}通过Deserialize<T>方法来实现。测试：Customer c1 = ScriptDeserialize(strJson);Console.WriteLine(c1.Unid + " " + c1.Custome

下载个关于json的dll

　　Json与.Net对象的转换主要可以用System.Web.Script.Serialization.JavaScriptSerializer和System.Runtime.Serialization.Json.DataContractJsonSerializer这两个类。此外也可以用第三方的如Json.Net。 　　JavaScriptSerializer 　　JavaScriptSerializer是一个简单的会序列化类里面所有公共的属性和实例字段，它不受System.Runtime.Serialization.IgnoreDataMember，NonSerialized之类的控制，例如对这样一个类Foo：　　[Serializable] 　　[System.Runtime.Serialization.DataContract] 　　public partial class Foo　　{ 　　[System.Runtime.Serialization.DataMember] 　　public string PageName1 { get; set; } 　　[System.Runtime.Serialization.IgnoreDataMember] 　　public string PageName2 { get; set; } 　　public string PageName3 { get; set; } 　　[NonSerialized] 　　public string PageName4; 　　public string PageName5; 　　public static string PageName6; 　　private string PageName7;　　} 　　进行序列化： 　　var javaScriptSerializer = new System.Web.Script.Serialization.JavaScriptSerializer(); 　　var jsonString = javaScriptSerializer.Serialize(obj); 　　会得到类似下面的结果：{PageName4:null,PageName5:null,PageName1:null,PageName2:null,PageName3:null} 　　另外JavaScriptSerializer也可以对匿名类型进行序列化。 　　DataContractJsonSerializer 　　DataContractJsonSerializer主要用于wcf中，它会受到IgnoreDataMember之类的控制，同样是上边的类，序列化的结果就不一样了： 　　var dcSerializer = new System.Runtime.Serialization.Json.DataContractJsonSerializer(typeof(Foo)); 　　using (var mem = new System.IO.MemoryStream())　　{ 　　dcSerializer.WriteObject(mem, obj); 　　jsonString = System.Text.Encoding.UTF8.GetString(mem.ToArray());　　} 　　结果是{PageName1:null}。因为只有PageName1是DataMember。 　　如果把类前面的[System.Runtime.Serialization.DataContract]去掉，生成的结果是这样：{PageName5:null,PageName7:null,<PageName1k__BackingField:null,<PageName2k__BackingField:null,<PageName3k__BackingField:null}可见此时它会无视DataMember特性并且会把私有字段也序列号了，还会在属性的名字上加一些奇怪的东西。 　　如果把[Serializable]也去掉结果是这样：{PageName1:null,PageName3:null,PageName4:null,PageName5:null}此时会无视NonSerialized却没有无视IgnoreDataMember。 　　所以在使用DataContractJsonSerializer的时候还是建议老老实实的使用DataContract和DataMember来控制想要序列化的东西，一般情况下就用JavaScriptSerializer。　　 ，本站保留追究责任的权利。

添加引用行...添加引用→.Net→System.Web.Entensions；再项目文件再using System.Web.Script.Serialization; OK...

打开文件: C:/WINDOWS/Microsoft.NET/Framework/v4.0.30319/Microsoft.Common.Targets找到 <GenerateResource…TrackFileAccess="$(TrackFileAccess)"TrackerLogDirectory="$(TrackerLogDirectory)"… </GenerateResource>删除TrackFileAccess="$(TrackFileAccess)"TrackerLogDirectory="$(TrackerLogDirectory)"

一、将NSDictionary或NSArray转化为JSON串// 将字典或者数组转化为JSON串- (NSData *)toJSONData:(id)theData{ NSError *error = nil; NSData *jsonData = [NSJSONSerialization dataWithJSONObject:theData options:NSJSONWritingPrettyPrinted error:&error]; if ([jsonData length] > 0 && error == nil){ return jsonData; }else{ return nil; }}使用这个方法的返回，我们就可以得到想要的JSON串NSString *jsonString = [[NSString alloc] initWithData:jsonData encoding:NSUTF8StringEncoding];二、将JSON串转化为NSDictionary或NSArray将NSString转化为NSData[jsonString dataUsingEncoding:NSASCIIStringEncoding];// 将JSON串转化为字典或者数组- (id)toArrayOrNSDictionary:(NSData *)jsonData{ NSError *error = nil; id jsonObject = [NSJSONSerialization JSONObjectWithData:jsonData options:NSJSONReadingAllowFragments error:&error]; if (jsonObject != nil && error == nil){ return jsonObject; }else{ // 解析错误 return nil; }}三、将JSON串与NSArray和NSDictionary的操作进行封装当然，也有很多时候，我们将这些操作，分别定义在NSObject和NSString的一个分类中直接贴：1.将NSString转化为NSArray或者NSDictionary#import "NSString+JSONCategories.h"@implementation NSString(JSONCategories)-(id)JSONValue;{ NSData* data = [self dataUsingEncoding:NSUTF8StringEncoding]; __autoreleasing NSError* error = nil; id result = [NSJSONSerialization JSONObjectWithData:data options:kNilOptions error:&error]; if (error != nil) return nil; return result;}@end2.将NSArray或者NSDictionary转化为NSString#import "NSObject+JSONCategories.h"@implementation NSObject (JSONCategories)-(NSData*)JSONString;{ NSError* error = nil; id result = [NSJSONSerialization dataWithJSONObject:self options:kNilOptions error:&error]; if (error != nil) return nil; return result;}@end

是不是机器名改过了