C#实现的序列化通用类实例
本文实例讲述了C#实现的序列化通用类。分享给大家供大家参考。具体如下：
usingSystem;
usingSystem.IO;
usingSystem.IO.Compression;
usingSystem.Runtime.Serialization.Formatters.Binary;
usingSystem.Runtime.Serialization.Formatters.Soap;
usingSystem.Text;
usingSystem.Xml;
usingSystem.Xml.Serialization;
namespacePlatForm.Utilities
{
publicenumSerializedType:ushort
{
ByteArray=0,
Object=1,
String=2,
Datetime=3,
Bool=4,
//SByte=5,//Makesnosense.
Byte=6,
Short=7,
UShort=8,
Int=9,
UInt=10,
Long=11,
ULong=12,
Float=13,
Double=14,
CompressedByteArray=255,
CompressedObject=256,
CompressedString=257,
}
publicclassSerializeHelper
{
publicSerializeHelper()
{}
#regionXML序列化
///<summary>
///文件化XML序列化
///</summary>
///<paramname="obj">对象</param>
///<paramname="filename">文件路径</param>
publicstaticvoidSave(objectobj,stringfilename)
{
FileStreamfs=null;
try
{
fs=newFileStream(filename,FileMode.Create,FileAccess.Write,FileShare.ReadWrite);
XmlSerializerserializer=newXmlSerializer(obj.GetType());
serializer.Serialize(fs,obj);
}
catch(Exceptionex)
{
throwex;
}
finally
{
if(fs!=null)fs.Close();
}
}
///<summary>
///文件化XML反序列化
///</summary>
///<paramname="type">对象类型</param>
///<paramname="filename">文件路径</param>
publicstaticobjectLoad(Typetype,stringfilename)
{
FileStreamfs=null;
try
{
fs=newFileStream(filename,FileMode.Open,FileAccess.Read,FileShare.ReadWrite);
XmlSerializerserializer=newXmlSerializer(type);
returnserializer.Deserialize(fs);
}
catch(Exceptionex)
{
throwex;
}
finally
{
if(fs!=null)fs.Close();
}
}
///<summary>
///文本化XML序列化
///</summary>
///<paramname="item">对象</param>
publicstringToXml<T>(Titem)
{
XmlSerializerserializer=newXmlSerializer(item.GetType());
StringBuildersb=newStringBuilder();
using(XmlWriterwriter=XmlWriter.Create(sb))
{
serializer.Serialize(writer,item);
returnsb.ToString();
}
}
///<summary>
///文本化XML反序列化
///</summary>
///<paramname="str">字符串序列</param>
publicTFromXml<T>(stringstr)
{
XmlSerializerserializer=newXmlSerializer(typeof(T));
using(XmlReaderreader=newXmlTextReader(newStringReader(str)))
{
return(T)serializer.Deserialize(reader);
}
}
#endregion
#regionSoapFormatter序列化
///<summary>
///SoapFormatter序列化
///</summary>
///<paramname="item">对象</param>
publicstaticstringToSoap<T>(Titem)
{
SoapFormatterformatter=newSoapFormatter();
using(MemoryStreamms=newMemoryStream())
{
formatter.Serialize(ms,item);
ms.Position=0;
XmlDocumentxmlDoc=newXmlDocument();
xmlDoc.Load(ms);
returnxmlDoc.InnerXml;
}
}
///<summary>
///SoapFormatter反序列化
///</summary>
///<paramname="str">字符串序列</param>
publicstaticTFromSoap<T>(stringstr)
{
XmlDocumentxmlDoc=newXmlDocument();
xmlDoc.LoadXml(str);
SoapFormatterformatter=newSoapFormatter();
using(MemoryStreamms=newMemoryStream())
{
xmlDoc.Save(ms);
ms.Position=0;
return(T)formatter.Deserialize(ms);
}
}
#endregion
#regionBinaryFormatter序列化
///<summary>
///BinaryFormatter序列化
///</summary>
///<paramname="item">对象</param>
publicstaticstringToBinary<T>(Titem)
{
BinaryFormatterformatter=newBinaryFormatter();
using(MemoryStreamms=newMemoryStream())
{
formatter.Serialize(ms,item);
ms.Position=0;
byte[]bytes=ms.ToArray();
StringBuildersb=newStringBuilder();
foreach(bytebtinbytes)
{
sb.Append(string.Format("{0:X2}",bt));
}
returnsb.ToString();
}
}
///<summary>
///BinaryFormatter反序列化
///</summary>
///<paramname="str">字符串序列</param>
publicstaticTFromBinary<T>(stringstr)
{
intintLen=str.Length/2;
byte[]bytes=newbyte[intLen];
for(inti=0;i<intLen;i++)
{
intibyte=Convert.ToInt32(str.Substring(i*2,2),16);
bytes[i]=(byte)ibyte;
}
BinaryFormatterformatter=newBinaryFormatter();
using(MemoryStreamms=newMemoryStream(bytes))
{
return(T)formatter.Deserialize(ms);
}
}
#endregion
///<summary>
///将对象序列化为二进制字节
///</summary>
///<paramname="obj">待序列化的对象</param>
///<returns></returns>
publicstaticbyte[]SerializeToBinary(objectobj)
{
byte[]bytes=newbyte[2500];
using(MemoryStreammemoryStream=newMemoryStream())
{
BinaryFormatterbformatter=newBinaryFormatter();
bformatter.Serialize(memoryStream,obj);
memoryStream.Seek(0,0);
if(memoryStream.Length>bytes.Length)
{
bytes=newbyte[memoryStream.Length];
}
bytes=memoryStream.ToArray();
}
returnbytes;
}
///<summary>
///从二进制字节中反序列化为对象
///</summary>
///<paramname="type">对象的类型</param>
///<paramname="bytes">字节数组</param>
///<returns>反序列化后得到的对象</returns>
publicstaticobjectDeserializeFromBinary(Typetype,byte[]bytes)
{
objectresult=newobject();
using(MemoryStreammemoryStream=newMemoryStream(bytes))
{
BinaryFormatterserializer=newBinaryFormatter();
result=serializer.Deserialize(memoryStream);
}
returnresult;
}
///<summary>
///将文件对象序列化到文件中
///</summary>
///<paramname="obj">待序列化的对象</param>
///<paramname="path">文件路径</param>
///<paramname="fileMode">文件打开模式</param>
publicstaticvoidSerializeToBinary(objectobj,stringpath,FileModefileMode)
{
using(FileStreamfs=newFileStream(path,fileMode))
{
//ConstructaBinaryFormatteranduseittoserializethedatatothestream.
BinaryFormatterformatter=newBinaryFormatter();
formatter.Serialize(fs,obj);
}
}
///<summary>
///将文件对象序列化到文件中
///</summary>
///<paramname="obj">待序列化的对象</param>
///<paramname="path">文件路径</param>
publicstaticvoidSerializeToBinary(objectobj,stringpath)
{
SerializeToBinary(obj,path,FileMode.Create);
}
///<summary>
///从二进制文件中反序列化为对象
///</summary>
///<paramname="type">对象的类型</param>
///<paramname="path">二进制文件路径</param>
///<returns>反序列化后得到的对象</returns>
publicstaticobjectDeserializeFromBinary(Typetype,stringpath)
{
objectresult=newobject();
using(FileStreamfileStream=newFileStream(path,FileMode.Open))
{
BinaryFormatterserializer=newBinaryFormatter();
result=serializer.Deserialize(fileStream);
}
returnresult;
}
///<summary>
///获取对象的转换为二进制的字节大小
///</summary>
///<paramname="obj"></param>
///<returns></returns>
publicstaticlongGetByteSize(objectobj)
{
longresult;
BinaryFormatterbFormatter=newBinaryFormatter();
using(MemoryStreamstream=newMemoryStream())
{
bFormatter.Serialize(stream,obj);
result=stream.Length;
}
returnresult;
}
///<summary>
///克隆一个对象
///</summary>
///<paramname="obj">待克隆的对象</param>
///<returns>克隆的一个新的对象</returns>
publicstaticobjectClone(objectobj)
{
objectcloned=null;
BinaryFormatterbFormatter=newBinaryFormatter();
using(MemoryStreammemoryStream=newMemoryStream())
{
try
{
bFormatter.Serialize(memoryStream,obj);
memoryStream.Seek(0,SeekOrigin.Begin);
cloned=bFormatter.Deserialize(memoryStream);
}
catch//(Exceptione)
{
;
}
}
returncloned;
}
///<summary>
///从文件中读取文本内容
///</summary>
///<paramname="path">文件路径</param>
///<returns>文件的内容</returns>
publicstaticstringReadFile(stringpath)
{
stringcontent=string.Empty;
using(StreamReaderreader=newStreamReader(path))
{
content=reader.ReadToEnd();
}
returncontent;
}
publicstaticbyte[]Serialize(objectvalue,outSerializedTypetype,uintcompressionThreshold)
{
byte[]bytes;
if(valueisbyte[])
{
bytes=(byte[])value;
type=SerializedType.ByteArray;
if(bytes.Length>compressionThreshold)
{
bytes=compress(bytes);
type=SerializedType.CompressedByteArray;
}
}
elseif(valueisstring)
{
bytes=Encoding.UTF8.GetBytes((string)value);
type=SerializedType.String;
if(bytes.Length>compressionThreshold)
{
bytes=compress(bytes);
type=SerializedType.CompressedString;
}
}
elseif(valueisDateTime)
{
bytes=BitConverter.GetBytes(((DateTime)value).Ticks);
type=SerializedType.Datetime;
}
elseif(valueisbool)
{
bytes=newbyte[]{(byte)((bool)value?1:0)};
type=SerializedType.Bool;
}
elseif(valueisbyte)
{
bytes=newbyte[]{(byte)value};
type=SerializedType.Byte;
}
elseif(valueisshort)
{
bytes=BitConverter.GetBytes((short)value);
type=SerializedType.Short;
}
elseif(valueisushort)
{
bytes=BitConverter.GetBytes((ushort)value);
type=SerializedType.UShort;
}
elseif(valueisint)
{
bytes=BitConverter.GetBytes((int)value);
type=SerializedType.Int;
}
elseif(valueisuint)
{
bytes=BitConverter.GetBytes((uint)value);
type=SerializedType.UInt;
}
elseif(valueislong)
{
bytes=BitConverter.GetBytes((long)value);
type=SerializedType.Long;
}
elseif(valueisulong)
{
bytes=BitConverter.GetBytes((ulong)value);
type=SerializedType.ULong;
}
elseif(valueisfloat)
{
bytes=BitConverter.GetBytes((float)value);
type=SerializedType.Float;
}
elseif(valueisdouble)
{
bytes=BitConverter.GetBytes((double)value);
type=SerializedType.Double;
}
else
{
//Object
using(MemoryStreamms=newMemoryStream())
{
newBinaryFormatter().Serialize(ms,value);
bytes=ms.GetBuffer();
type=SerializedType.Object;
if(bytes.Length>compressionThreshold)
{
bytes=compress(bytes);
type=SerializedType.CompressedObject;
}
}
}
returnbytes;
}
privatestaticbyte[]compress(byte[]bytes)
{
using(MemoryStreamms=newMemoryStream())
{
using(DeflateStreamgzs=newDeflateStream(ms,CompressionMode.Compress,false))
{
gzs.Write(bytes,0,bytes.Length);
}
ms.Close();
returnms.GetBuffer();
}
}
privatestaticbyte[]decompress(byte[]bytes)
{
using(MemoryStreamms=newMemoryStream(bytes,false))
{
using(DeflateStreamgzs=newDeflateStream(ms,CompressionMode.Decompress,false))
{
using(MemoryStreamdest=newMemoryStream())
{
byte[]tmp=newbyte[bytes.Length];
intread;
while((read=gzs.Read(tmp,0,tmp.Length))!=0)
{
dest.Write(tmp,0,read);
}
dest.Close();
returndest.GetBuffer();
}
}
}
}
publicstaticobjectDeSerialize(byte[]bytes,SerializedTypetype)
{
switch(type)
{
caseSerializedType.String:
returnEncoding.UTF8.GetString(bytes);
caseSerializedType.Datetime:
returnnewDateTime(BitConverter.ToInt64(bytes,0));
caseSerializedType.Bool:
returnbytes[0]==1;
caseSerializedType.Byte:
returnbytes[0];
caseSerializedType.Short:
returnBitConverter.ToInt16(bytes,0);
caseSerializedType.UShort:
returnBitConverter.ToUInt16(bytes,0);
caseSerializedType.Int:
returnBitConverter.ToInt32(bytes,0);
caseSerializedType.UInt:
returnBitConverter.ToUInt32(bytes,0);
caseSerializedType.Long:
returnBitConverter.ToInt64(bytes,0);
caseSerializedType.ULong:
returnBitConverter.ToUInt64(bytes,0);
caseSerializedType.Float:
returnBitConverter.ToSingle(bytes,0);
caseSerializedType.Double:
returnBitConverter.ToDouble(bytes,0);
caseSerializedType.Object:
using(MemoryStreamms=newMemoryStream(bytes))
{
returnnewBinaryFormatter().Deserialize(ms);
}
caseSerializedType.CompressedByteArray:
returnDeSerialize(decompress(bytes),SerializedType.ByteArray);
caseSerializedType.CompressedString:
returnDeSerialize(decompress(bytes),SerializedType.String);
caseSerializedType.CompressedObject:
returnDeSerialize(decompress(bytes),SerializedType.Object);
caseSerializedType.ByteArray:
default:
returnbytes;
}
}
}
}
希望本文所述对大家的C#程序设计有所帮助。