#pragma once
namespace CarReview
{
using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;
using namespace System::IO;
--------------------------------------------------- System::Void btnWrite_Click(System::Object^ sender, System::EventArgs^ e)
{
String ^ Make = txtMake->Text;
String ^ Model = txtModel->Text;
int Year = int::Parse(txtYear->Text);
String ^ Color = txtColor->Text;
FileStream ^ stmCar = gcnew FileStream("Car1.car", FileMode::Create);
BinaryWriter ^ bnwCar = gcnew BinaryWriter(stmCar);
try
{
bnwCar->Write(Make);
bnwCar->Write(Model);
bnwCar->Write(Year);
bnwCar->Write(Color);
}
finally
{
bnwCar->Close();
stmCar->Close();
}
}
Here is an example of running the program:
This is an example of the techniques used in file processing to save individual data of primitive types:
The values can be retrieved with the following code: System::Void btnRead_Click(System::Object^ sender, System::EventArgs^ e)
{
FileStream ^ stmCar = gcnew FileStream("Car1.car", FileMode::Open);
BinaryReader ^ bnrCar = gcnew BinaryReader(stmCar);
try
{
txtMake->Text = bnrCar->ReadString();
txtModel->Text = bnrCar->ReadString();
txtYear->Text = bnrCar->ReadUInt32().ToString();
txtColor->Text = bnrCar->ReadString();
}
finally
{
bnrCar->Close();
stmCar->Close();
}
}
In the same way, you can save the individual fields of a class or you can retrieve the individual fields of a car:
Here is an example: ref class CCar
{
public:
String ^ Make;
String ^ Model;
int Year;
String ^ Color;
};
private:
System::Void btnWrite_Click(System::Object^ sender, System::EventArgs^ e)
{
CCar ^ vehicle = gcnew CCar;
vehicle->Make = txtMake->Text;
vehicle->Model = txtModel->Text;
vehicle->Year = int::Parse(txtYear->Text);
vehicle->Color = txtColor->Text;
FileStream ^ stmCar = gcnew FileStream("Car2.car", FileMode::Create);
BinaryWriter ^ bnwCar = gcnew BinaryWriter(stmCar);
try
{
bnwCar->Write(vehicle->Make);
bnwCar->Write(vehicle->Model);
bnwCar->Write(vehicle->Year);
bnwCar->Write(vehicle->Color);
}
finally
{
bnwCar->Close();
stmCar->Close();
}
}
System::Void btnRead_Click(System::Object^ sender, System::EventArgs^ e)
{
FileStream ^ stmCar = gcnew FileStream("Car2.car", FileMode::Open);
BinaryReader ^ bnrCar = gcnew BinaryReader(stmCar);
try
{
CCar ^ vehicle = gcnew CCar;
vehicle->Make = bnrCar->ReadString();
vehicle->Model = bnrCar->ReadString();
vehicle->Year = bnrCar->ReadUInt32();
vehicle->Color = bnrCar->ReadString();
txtMake->Text = vehicle->Make;
txtModel->Text = vehicle->Model;
txtYear->Text = vehicle->Year.ToString();
txtColor->Text = vehicle->Color;
}
finally
{
bnrCar->Close();
stmCar->Close();
}
}
};
}
When it comes to a class, the problem with saving individual fields is that you could forget to save one of the fields. For example, considering a CCar class, if you don't save the Make information of a CCar object and retrieve or open the saved object on another computer, the receiving user would miss some information and the car cannot be completely identifiable. An alternative is to save the whole CCar object. Object serialization consists of saving a whole object as one instead of its individual fields:
In other words, a variable declared from a class can be saved to a stream and then the saved object can be retrieved later or on another computer. The .NET Framework supports two types of object serialization: binary and SOAP.
Binary serialization works by processing an object rather than streaming its individual member variables. This means that, to use it, you define an object and initialize it, or "fill" it, with the necessary values and any information you judge necessary. This creates a "state" of the object. It is this state that you prepare to serialize. When you save the object, it is converted into a stream. To perform binary serialization, there are a few steps you must follow. When creating the class whose objects would be serialized, start it with the [Serializable] attribute. Here is an example: [Serializable]
public ref class CCar
{
public:
String ^ Make;
String ^ Model;
int Year;
String ^ Color;
};
Before serializing an object, you should reference the System::Runtime::Serialization::Formatters::Binary namespace. The class responsible for binary serialization is called BinaryFormatter. This class is equipped with two constructors. The default constructor is used to simply create an object. After declaring the variable, to actually serialize an object, call the Serialize() member function of the BinaryFormatter class. The member function is overloaded with two versions. One of the versions of this member function uses the following syntax: public:
virtual void Serialize(Stream^ serializationStream,
Object^ graph) sealed;
The first argument to this member function must be an object of a Stream-based class, such as a FileStream object. The second argument must be the object to serialize. This means that, before calling this member function, you should have built the object. Here is an example: #pragma once
namespace CarReview {
using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;
using namespace System::IO;
using namespace System::Runtime::Serialization::Formatters::Binary;
[Serializable]
ref class CCar
{
public:
String ^ Make;
String ^ Model;
int Year;
String ^ Color;
};
-------------------------------------------------------------------- System::Void btnWrite_Click(System::Object^ sender, System::EventArgs^ e)
{
CCar ^ vehicle = gcnew CCar;
vehicle->Make = txtMake->Text;
vehicle->Model = txtModel->Text;
vehicle->Year = int::Parse(txtYear->Text);
vehicle->Color = txtColor->Text;
FileStream ^ stmCar = gcnew FileStream("Car3.car",
FileMode::Create);
BinaryFormatter ^ bfmCar = gcnew BinaryFormatter;
bfmCar->Serialize(stmCar, vehicle);
}
As serialization is the process of storing an object to a medium, the opposite, serialization is used to retrieve an object from a stream. To support this, the BinaryFormatter class is equipped with the Deserialize() member function. Like Serialize(), the Deserialize() member function is overloaded with two versions. One of them uses the following syntax: public:
virtual Object^ Deserialize(Stream^ serializationStream) sealed;
This member function takes as argument a Stream-based object, such as a FileStream variable, that indicates where the file is located. The Deserialize() member function returns an Object object. As a goal, you want the Deserialize() member function to produce the type of object that was saved so you can retrieve the values that the returned object holds. Because the member function returns an Object value, you must cast the returned value to the type of your class. Once the Deserialize() member function has returned the desired object, you can access its values. Here is an example: System::Void btnRead_Click(System::Object^ sender, System::EventArgs^ e)
{
FileStream ^ stmCar = gcnew FileStream("Car3.car",
FileMode::Open);
BinaryFormatter ^ bfmCar = gcnew BinaryFormatter;
CCar ^ vehicle = (CCar ^)bfmCar->Deserialize(stmCar);
txtMake->Text = vehicle->Make;
txtModel->Text = vehicle->Model;
txtYear->Text = vehicle->Year.ToString();
txtColor->Text = vehicle->Color;
}
|
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Practical
Learning: Introducing Serialization
