建立一个Serialization类，包括两个静态方法Save和Get。见程序中的
必须注意，对要序列化的类，以及其包括的其他结构和类，都必须用[Serializable]或者[NonSerialized]来标记。

NET Serialization By Vyacheslav Biktagirov
.NET enters in our life. So, we must at least learn what about new technoloy of. I think, that XML persistance is one of keys that make .NET belling so good.. OK. So what about persisting of? Imagine we have a class value. In C# termines, like that:
public class NiceClass
{
public long SomeLong=10;
private string str="Now nothing";
public int SomeInt=15;
public string SomeString
{
get
{
return str;
}
set
{
str=value;
}
}
public NiceClass()
{
}
}

Okay, it has some members and one property. Now, we get instance of such class:
NiceClass x=new NiceClass();
Now we work with it and, after work, want to "save" the class to some stream and "send" it to inother application. How we do such a thing? There is special class, named BinaryFormatter, that can take class instance, "save" it in binary format. Than, we can send it to any stream, and restore for our enjoy. But, this class needs some info about our class, like what members we want to store and what not. How we can did it? There is special C# mechanism for class self-describing named "custom properties". Let's do it:

[Serializable]// says class to be serializable
public class NiceClass
{
public long SomeLong=10;
private string str="Now nothing";
[NonSerialized] public int SomeInt=15; // this member is not for serialization
public string SomeString
{
get
{
return str;
}
set
{
str=value;
}
}
public NiceClass()
{
}


Now, after we sayd what exactly we want to serialize, let's do it:
NiceClass x=new NiceClass(); // Get instance
x.SomeInt=20; // Do something
x.SomeLong=30;
x.SomeString="Bikta";
BinaryFormatter bf = new BinaryFormatter();
MemoryStream ms=new MemoryStream(); // Stream
bf.Serialize(ms,x); // "Save" object state
NiceClass y=new NiceClass();
ms.Seek(0,0); // Return stream to start
y=(NiceClass)bf.Deserialize(ms); // Restore object

Nice, is it?

But what about we want save class in SOAP format for sending via HTTP ? No problem. SoapFormatter will help us.[Serializable] property will help us as with BinaryFormatter. So:

byte[] buffer=new byte[200];
NiceClass x=new NiceClass();
x.SomeInt=20;
x.SomeLong=30;
x.SomeString="Bikta";
SoapFormatter bf = new SoapFormatter();
MemoryStream ms=new MemoryStream();
bf.Serialize(ms,x);
NiceClass y=new NiceClass();
ms.Seek(0,0);
y=(NiceClass)bf.Deserialize(ms);
ms.Seek(0,0);
ms.Read(buffer,0,200);
string s=System.Text.Encoding.ASCII.GetString(buffer,0,200);
MessageBox.Show(Form.ActiveForm,s); // Look SOAP

But what about simple XML, without SOAP-specific additions? No problem.XmlSerializer, help us!

byte[] buffer=new Byte[200];
NiceClass x=new NiceClass();
x.SomeInt=20;
x.SomeLong=30;
x.SomeString="Bikta";
XmlSerializer xs=new XmlSerializer(x.GetType());
MemoryStream ms=new MemoryStream();
xs.Serialize(ms,x);
ms.Seek(0,0);
NiceClass y;
y=(NiceClass)xs.Deserialize(ms);
ms.Seek(0,0);
ms.Read(buffer,0,200);
string s=System.Text.Encoding.ASCII.GetString(buffer,0,200);
MessageBox.Show(Form.ActiveForm,s); // XML, here are you?

But pay attention, that XmlSerializer ignores [Serializable] property! It uses it's own property named [XmlIgnore] for marking non-serialized members. So we change the class:


 public class NiceClass
{
public long SomeLong=10;
private string str="Now nothing";
[XmlIgnore] public int SomeInt=15;// Added XmlIgnore
public string SomeString
{
get
{
return str;
}
set
{
str=value;
}
}
public NiceClass()
{
}

Now it will work as we want. Pay attention, that it is no any problem to serialize private(!) string member!!! How formatters do it? What's your opinion? Thay just use "unsafe" code. But about that - in next article..