首页 | 社区 | 博客 | 招聘 | 文章 | 新闻 | 下载 | 项目交易 | 网友作品 | 读书 | ACM题库 | 源码
亲,您未登录哦! 登录 | 注册

实例解析C++/CLI的串行化

(加入日期: 2006-09-09 )

打印文章】【字体:

分享到:
 
  串行化可使对象被转换为某种外部的形式,比如以文件存储的形式供程序使用,或通过程序间的通讯发送到另一个处理过程。转换为外部形式的过程称为"串行化",而逆过程称为"反串行化"。

  简介
  
  请看例1中的示例,其将多个对象类型的值写入到一个新的磁盘文件中,关闭文件,接着再把这些值重新读取到内存中。

  例1:

using namespace System;
using namespace System::IO;
using namespace System::Runtime::Serialization::Formatters::Binary;

int main()
{
 array<int>^ intArray = {10, 20, 30};
 array<float,2>^ floatArray = {
  {1.2F, 2.4F},
  {3.5F, 6.8F},
  {8.4F, 9.7F}
 };
 DateTime dt = DateTime::Now;
 Console::WriteLine("dt >{0}<", dt);

 /*1*/ BinaryFormatter^ formatter = gcnew BinaryFormatter;

 //将数据串行化到一个文件

 /*2*/ Stream^ file = File::Open("Sr01.ser", FileMode::Create);

 /*3a*/ formatter->Serialize(file, "Hello");
 /*3b*/ formatter->Serialize(file, intArray);
 /*3c*/ formatter->Serialize(file, floatArray);
 /*3d*/ formatter->Serialize(file, true);
 /*3e*/ formatter->Serialize(file, dt);
 /*3f*/ formatter->Serialize(file, 1000);
 /*3g*/ formatter->Serialize(file, L''X'');
 /*3h*/ formatter->Serialize(file, 1.23456F);

 /*4*/ file->Close();

 //从文件中反串行化数据--即读取数据

 /*5*/ file = File::Open("Sr01.ser", FileMode::Open);

 /*6a*/ String^ s = static_cast<String^>(formatter->Deserialize(file));
 Console::WriteLine("String >{0}<", s);

 /*6b*/ array<int>^ newIntArray =
 static_cast<array<int>^>(formatter->Deserialize(file));
 Console::WriteLine("newIntArray:");
 for (int i = 0; i < newIntArray->Length; ++i)
 {
  Console::Write(" {0}", newIntArray[i]);
 }
 Console::WriteLine();

 /*6c*/ array<float,2>^ newFloatArray =
 static_cast<array<float,2>^>(formatter->Deserialize(file));
 Console::WriteLine("newFloatArray:");
 for (int i = 0; i < 3; ++i)
 {
  for (int j = 0; j < 2; ++j)
  {
   Console::Write(" {0}", newFloatArray[i,j]);
  }
  Console::WriteLine();
 }

 /*6d*/ bool b = static_cast<bool>(formatter->Deserialize(file));
 Console::WriteLine("bool >{0}<", b);

 /*6e*/ DateTime newDT = static_cast<DateTime>(formatter->Deserialize(file));
 Console::WriteLine("newDT >{0}<", newDT);

 /*6f*/ int v = static_cast<int>(formatter->Deserialize(file));
 Console::WriteLine("int >{0}<", v);

 /*6g*/ wchar_t c = static_cast<wchar_t>(formatter->Deserialize(file));
 Console::WriteLine("wchar_t >{0}<", c);

 /*6h*/ float f = static_cast<float>(formatter->Deserialize(file));
 Console::WriteLine("float >{0}<", f);

 /*7*/ file->Close();
}

  在标记1中,我们定义了一个BinaryFormatter类型的变量,此种类型的任意对象都可以二进制的形式进行串行与反串行化。

  在标记2中,用指定的名称创建了一个新的文件,后缀 .ser没有特别的意思,这是约定俗成的表示这是一个串行化数据文件。从标记3a至3h,表示一个对象被串行化至文件中。在字符串的情况下,每个字符都被写入;在数组的情况下,所有元素都被写入;在日期时间的情况下,类型中包含的所有数据及有关依赖项都被写入;在为原始类型值的情况下,它们先被装箱,然后对应的对象被写入。上述动作中,串行化只需要接收一个Object^类型参数的对象即可。

  通过调用Deserialize函数,可取回串行化后的数据,如标记6a中所示;因为此函数返回一个Object^类型的值,所以需要把它转换为相应的值。程序的输出如插1所示:

  插1:例1中串行化、反串行化的输出

String >Hello<
newIntArray
10 20 30
newFloatArray:
1.2 2.4
3.5 6.8
8.4 9.7
bool >True<
newDT >9/29/2005 3:25:44 PM<
int >1000<
wchar_t >X<
float >1.23456<



  串行化包含引用的对象

  在前一个例子中,我们对相关类型进行了简单的读写。那么,如果一个对象中包含了其他对象的句柄呢?试想有一个超过两万字的字典,存储在一个能通过键值索引的集合中,而在标准模板库中,就提供了一个这样的集合--哈希表(Hashtable),如例2中所示:

  例2:

using namespace System;
using namespace System::IO;
using namespace System::Collections;
using namespace System::Runtime::Serialization::Formatters::Binary;

int main()
{
 /*1*/ Hashtable^ dictionary = gcnew Hashtable(21000);

 StreamReader^ inStream = File::OpenText("dictionary.txt"); //打开字典文件
 String^ str;

 while ((str = inStream->ReadLine()) != nullptr)
 {
  /*2*/ dictionary->Add(str, nullptr);
 }

 inStream->Close();
 /*3*/ Console::WriteLine("Dictionary contains {0} entries", dictionary->Count);

 BinaryFormatter^ formatter = gcnew BinaryFormatter();
 Stream^ file = File::Open("dictionary.ser", FileMode::Create);
 /*4*/ formatter->Serialize(file, dictionary);
 file->Close();
}

  在标记1中,我们先分配了一个初始化为21000个条目的哈希表(这样做只是为了加快处理速度,在条目相加时不需要重新进行分配),接着从一个文本文件中,一次一行地读入字,并将其添加到标记2的哈希表中。请注意,在定义中,哈希表的每个条目都由(键/值)对组成。但在我们的程序中,键也是值,所以在第二个参数中使用了nullprt。

  哈希表中的键值必须是唯一的,而添加进来的任何类型的对象都必须重载System::对象名 GetHashCode函数--字符串也一样。

  一旦文件中所有的字被读取并添加到哈希表中,就可通过一个简单的Serialize调用,把哈希表写到磁盘上,如标记4所示。在例3中,我们读入这个字典,并在其中查找用户提供的字,插2是对应的输出。

  例3:

using namespace System;
using namespace System::IO;
using namespace System::Collections;
using namespace System::Runtime::Serialization::Formatters::Binary;

int main()
{
 BinaryFormatter^ formatter = gcnew BinaryFormatter;

 Stream^ file = File::Open("dictionary.ser", FileMode::Open);
 /*1*/ Hashtable^ dictionary = static_cast<Hashtable^>(formatter->Deserialize(file));
 file->Close();

 /*2*/ Console::WriteLine("Dictionary contains {0} entries", dictionary->Count);

 String^ word;
 while (true)
 {
  Console::Write("Enter a word: ");
  word = Console::ReadLine();
  if (word == nullptr)
  {
   break;
  }
  /*3*/ Console::WriteLine("{0}{1} found", word, (dictionary->Contains(word) ? "" : " not"));
 }
}

  插2:使用反串行化进行字典查找

Dictionary contains 20159 entries
Enter a word: house
house found
Enter a word: houses
houses not found
Enter a word: brick
brick found
Enter a word: manly
manly not found

  此处最重要的是,我们能在单个函数调用中,串行、反串行化任意大小、任意复杂性的对象。


 处理多个句柄

  当我们传递一个对象的句柄给Serialize时,似乎会在底层对对象进行一个复制,那么,实际情况真的是这样吗?假设我们把包含有多个句柄的一个对象写入到其他对象中,或者我们调用Serialize两次,每次都给它同一个对象的句柄呢?我们真的想得到同一对象的多个副本吗?在例4中演示了这个过程:

 例4:

using namespace System;
using namespace System::IO;
using namespace System::Runtime::Serialization::Formatters::Binary;

/*1*/ [Serializable]
ref class Employee { /* ... */};

int main()
{
 Employee^ emp1 = gcnew Employee();
 Employee^ emp2 = gcnew Employee();
 Employee^ emp3 = emp2;
 /*2a*/ Console::WriteLine("emp1 == emp2 is {0}", (emp1 == emp2));
 /*2b*/ Console::WriteLine("emp2 == emp3 is {0}", (emp2 == emp3));
 /*2c*/ Console::WriteLine("emp1 == emp3 is {0}", (emp1 == emp3));

 array<Object^>^ list = gcnew array<Object^>(2);
 list[0] = emp1;
 list[1] = list[0];
 /*2d*/ Console::WriteLine("list[0] == list[1] is {0}", (list[0] == list[1]));
 /*2e*/ Console::WriteLine("list[0] == emp1 is {0}", (list[0] == emp1));
 /*2f*/ Console::WriteLine("list[1] == emp1 is {0}", (list[1] == emp1));

 //将数据串行化到文件

 BinaryFormatter^ formatter = gcnew BinaryFormatter;
 Stream^ file = File::Open("Sr03.ser", FileMode::Create);

 /*3a*/ formatter->Serialize(file, emp1);
 /*3b*/ formatter->Serialize(file, emp2);
 /*3c*/ formatter->Serialize(file, emp3);
 /*3d*/ formatter->Serialize(file, list);

 file->Close();

 //从文件中反串行化数据--即读取数据

 file = File::Open("Sr03.ser", FileMode::Open);

 /*4a*/ emp1 = static_cast<Employee^>(formatter->Deserialize(file));
 /*4b*/ emp2 = static_cast<Employee^>(formatter->Deserialize(file));
 /*4c*/ emp3 = static_cast<Employee^>(formatter->Deserialize(file));
 /*4d*/ list = static_cast<array<Object^>^>(formatter->Deserialize(file));

 file->Close();

 /*5a*/ Console::WriteLine("emp1 == emp2 is {0}", (emp1 == emp2));
 /*5b*/ Console::WriteLine("emp2 == emp3 is {0}", (emp2 == emp3));
 /*5c*/ Console::WriteLine("emp1 == emp3 is {0}", (emp1 == emp3));
 /*5d*/ Console::WriteLine("list[0] == list[1] is {0}", (list[0] == list[1]));
 /*5e*/ Console::WriteLine("list[0] == emp1 is {0}", (list[0] == emp1));
 /*5f*/ Console::WriteLine("list[1] == emp1 is {0}", (list[1] == emp1));
}

  在本例中,我们想对Employee类型(在标记1中的用户自定义类型)的对象进行串行化,必须把Serializable属性附加到这个类型上。如果我们试图串行化一个没有标明此属性的类对象,将会抛出一个System::Runtime::Serialization::SerializationException类型的异常。串行化之前的程序输出如插3所示:

  插3:串行化之前例4的输出

emp1 == emp2 is False
emp2 == emp3 is True
emp1 == emp3 is False
list[0] == list[1] is True
list[0] == emp1 is True
list[1] == emp1 is True

  我们对四个目标进行了串行化,前两个代表了不同的Employee对象,而第三个是对第二个的引用,第四个为包含两个元素的数组,这两个元素均引用第一个Employee对象。程序的输出表明了它们之间的这些关系,反串行化之后的输出见插4:

  插4:反串行化之后例4的输出

emp1 == emp2 is False
emp2 == emp3 is False
emp1 == emp3 is False
list[0] == list[1] is True
list[0] == emp1 is False
list[1] == emp1 is False

  注意,现在第三个Employee句柄已不再是一个指向第二个Employee对象的句柄了,类似地,尽管list[0]与list[1]都引用同一个Empolyee对象,但对象已不是我们取回的第一个对象了。

  在此应看到,当多个对象逐个串行化之后,它们是相关联的,而当反串行化之后,它们的关系并没有因此而恢复,但是,对象内部的关系仍然被维持。

  自定义的串行化

  默认情况下,当一个对象被串行化时,所有的非静态实例字段都会被写入,并在反串行化期间顺序读回;然而,对包含静态字段的类,这可能会导致一个问题。

  在例5中使用了Point类,其不但包含了用于追踪每个Point x与y坐标的实例变量,而且还会跟踪在程序执行期间创建的Point数目。例如,在例5中,通过显示构造函数调用,创建了4个Point,并将它们串行化到磁盘;当它们被反串行化时,又创建了4个新的Point,因此Point总数现在为8,插5中是程序的输出:

  例5:

using namespace System;
using namespace System::IO;
using namespace System::Runtime::Serialization::Formatters::Binary;

int main()
{
 Console::WriteLine("PointCount: {0}", Point::PointCount);
 Point^ p1 = gcnew Point(15, 10);
 Point^ p2 = gcnew Point(-2, 12);
 array<Point^>^ p3 = {gcnew Point(18, -5), gcnew Point(25, 19)};
 Console::WriteLine("PointCount: {0}", Point::PointCount);
 
 BinaryFormatter^ formatter = gcnew BinaryFormatter;
 Stream^ file = File::Open("Point.ser", FileMode::Create);

 formatter->Serialize(file, p1);
 formatter->Serialize(file, p2);
 formatter->Serialize(file, p3);
 
 file->Close();

 file = File::Open("Point.ser", FileMode::Open);

 Point^ p4 = static_cast<Point^>(formatter->Deserialize(file));
 Console::WriteLine("PointCount: {0}", Point::PointCount);
 Point^ p5 = static_cast<Point^>(formatter->Deserialize(file));
 Console::WriteLine("PointCount: {0}", Point::PointCount);
 array<Point^>^ p6 = static_cast<array<Point^>^>(formatter->Deserialize(file));
 Console::WriteLine("PointCount: {0}", Point::PointCount);

 file->Close();

 Console::WriteLine("p1: {0}, p4: {1}", p1, p4);
 Console::WriteLine("p2: {0}, p5: {1}", p2, p5);
 Console::WriteLine("p3[0]: {0}, p6[0]: {1}", p3[0], p6[0]);
 Console::WriteLine("p3[1]: {0}, p6[1]: {1}", p3[1], p6[1]);
}

  插5:反串行化创建了4个新的Point

PointCount: 0
PointCount: 4
PointCount: 5
PointCount: 6
PointCount: 8
p1: (15,10), p4: (15,10)
p2: (-2,12), p5: (-2,12)
p3[0]: (18,-5), p6[0]: (18,-5)
p3[1]: (25,19), p6[1]: (25,19)

  当调用Point类的公有构造函数来构造一个新对象时,Point计数字段也会相应增长;而当我们反串行化一个或多个Point时,问题发生了,对Point的Deserialize调用实际上创建了一个新的Point对象,但它并没有为这些对象调用任何的构造函数啊。另外要明确一点,即使新Point数被增量1 ,PointCount也不会自动增长。我们可重载由接口ISerializable(从System::Runtime::Serialization)实现的默认的串行与反串行动作;这个接口需要定义一个调用GetObjectData的函数,这个函数就可以允许我们重载串行化过程。

  GetObjectData函数的目的是,以串行化一个父类对象所需的数据,增加一个SerializationInfo对象,在此,名称、值、类型信息都被提供给AddValue函数,并由对象作为第二个参数。名称字符串可为任意,只要它在这种类型的串行化中唯一就行了。(如果使用了两个相同的名称,会抛出SerializationException异常。)

  如果要重载反串行化过程,必须定义另一个构造函数,注意这个构造为私有类型,因为它只会被反串行化机制所调用,没有从外部访问的必要。

  串行化的格式
  
  以上所有串行化的例子当中,我们使用了BinaryFormatter类型,其以某种能被高效地处理的压缩格式来存储数据;然而,其他格式也能做到这点,例如,可使用一个SOAP,SOAP(Simple Object Access Protocol--简单对象访问协议)是一种用于在Web上交换结构化及类型信息的简单的、基于XML的协议,该协议未包含任何应用程序或传输语义,所以它具有高度模块化及扩展性的特点。当然,大家也能创建其他的自定义格式。

本栏文章均来自于互联网,版权归原作者和各发布网站所有,本站收集这些文章仅供学习参考之用。任何人都不能将这些文章用于商业或者其他目的。( Pfan.cn )

编程爱好者论坛

本栏最新文章