请看例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的协议，该协议未包含任何应用程序或传输语义，所以它具有高度模块化及扩展性的特点。当然，大家也能创建其他的自定义格式。