public byte[] Save(object instance)
{
Type type = instance.GetType();
TreePackage package = new TreePackage();
package.Attributes.Add("Type", type.AssemblyQualifiedName);
foreach (PropertyInfo property in type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
{
if (!property.CanRead)
{
continue;
}
if (AttributeExtensions.IsDefined <NonPackageAttribute>(property) || AttributeExtensions.IsDefined <Formatting.IgnoreAttribute>(property))
{
continue;
}
package.Add(property.Name, property.GetValue(instance, new object[0]));
}
foreach (FieldInfo field in type.GetFields(BindingFlags.Public | BindingFlags.Instance))
{
if (AttributeExtensions.IsDefined <NonPackageAttribute>(field) || AttributeExtensions.IsDefined <Formatting.IgnoreAttribute>(field))
{
continue;
}
package.Add(field.Name, field.GetValue(instance));
}
return(package.Save());
}
Type GetElementType(Type type, Entry entry)
{
Type result = null;
//数组
if (type.IsArray)
{
result = type.GetElementType(); //获取元素类型
if (result == typeof(object)) //object[]
{
entry.ArrayType = PackageArrayTypes.Object_Array;
}
else //T[]
{
entry.ArrayType = PackageArrayTypes.T_Array;
}
return(result);
}
//if (type.FullName == "System.Windows.Forms.Cursor") {
// entry.ValueType = PackageValueTypes.Cursor;
//}
if (IsTheTypes(type, typeof(TreePackage)))
{
entry.ValueType = PackageValueTypes.NestedPackage;
return(type);
}
if (AttributeExtensions.IsDefined <CustomPackageAttribute>(type))
{
entry.ValueType = PackageValueTypes.Object;
return(type);
}
//IDictionary<T1,T2>,IDictionary(Hashtable)
if (IsTheTypes(type, typeof(IDictionary <,>), typeof(System.Collections.IDictionary)))
{
Type[] argTypes = type.GetGenericArguments();
result = typeof(object);
entry.ArrayType = PackageArrayTypes.Dictionary;
return(result);
}
if (IsTheTypes(type, typeof(ICollection <>)))
{
result = type.GetGenericArguments()[0];//IList<T>,ICollection<T>
if (result == typeof(object))
{
entry.ArrayType = PackageArrayTypes.Object_List;
}
else
{
entry.ArrayType = PackageArrayTypes.T_List;
}
}
else if (IsTheTypes(type, typeof(IEnumerable <>)))
{
result = type.GetGenericArguments()[0];//IEnumerable<T>
if (result == typeof(object))
{
entry.ArrayType = PackageArrayTypes.Object_Array;
}
else
{
entry.ArrayType = PackageArrayTypes.T_Array;
}
}
else if (IsTheTypes(type, typeof(IEnumerator <>)))
{
result = type.GetGenericArguments()[0];//IEnumerator<T>
if (result == typeof(object))
{
entry.ArrayType = PackageArrayTypes.Object_Array;
}
else
{
entry.ArrayType = PackageArrayTypes.T_Array;
}
}
else if (IsTheTypes(type, typeof(System.Collections.Specialized.NameValueCollection)))
{
result = typeof(object);//NameValueCollection
entry.ArrayType = PackageArrayTypes.NameValueCollection;
}
else if (IsTheTypes(type, typeof(System.Collections.IEnumerable), typeof(System.Collections.IEnumerator)))
{
result = typeof(object);//IList,ICollection
entry.ArrayType = PackageArrayTypes.Object_List;
}
else
{
result = type;
}
return(result);
}
unsafe static TreePackage()
{
#region typecode map ValueType
_typeCodes = new Dictionary <TypeCode, PackageValueTypes>();
_typeCodes.Add(TypeCode.Boolean, PackageValueTypes.Boolean);
_typeCodes.Add(TypeCode.Byte, PackageValueTypes.Byte);
_typeCodes.Add(TypeCode.Char, PackageValueTypes.Char);
_typeCodes.Add(TypeCode.Int16, PackageValueTypes.Int16);
_typeCodes.Add(TypeCode.Int32, PackageValueTypes.Int32);
_typeCodes.Add(TypeCode.Int64, PackageValueTypes.Int64);
_typeCodes.Add(TypeCode.Single, PackageValueTypes.Single);
_typeCodes.Add(TypeCode.Double, PackageValueTypes.Double);
_typeCodes.Add(TypeCode.SByte, PackageValueTypes.SByte);
_typeCodes.Add(TypeCode.Decimal, PackageValueTypes.Decimal);
_typeCodes.Add(TypeCode.UInt16, PackageValueTypes.UInt16);
_typeCodes.Add(TypeCode.UInt32, PackageValueTypes.UInt32);
_typeCodes.Add(TypeCode.UInt64, PackageValueTypes.UInt64);
_typeCodes.Add(TypeCode.DateTime, PackageValueTypes.DateTime);
_typeCodes.Add(TypeCode.String, PackageValueTypes.String);
_typeCodes.Add(TypeCode.Object, PackageValueTypes.Object);
_typeCodes.Add(TypeCode.DBNull, PackageValueTypes.Object);
_typeCodes.Add(TypeCode.Empty, PackageValueTypes.Object);
#endregion
#region type map ValueType
_typeValueTypes = new Dictionary <Type, PackageValueTypes>();
_typeValueTypes.Add(typeof(string), PackageValueTypes.String);
_typeValueTypes.Add(typeof(IntPtr), PackageValueTypes.IntPtr);
_typeValueTypes.Add(typeof(UIntPtr), PackageValueTypes.UIntPtr);
_typeValueTypes.Add(typeof(TimeSpan), PackageValueTypes.TimeSpan);
_typeValueTypes.Add(typeof(Guid), PackageValueTypes.Guid);
_typeValueTypes.Add(typeof(System.Drawing.Icon), PackageValueTypes.Icon);
_typeValueTypes.Add(typeof(System.Drawing.Color), PackageValueTypes.Color);
_typeValueTypes.Add(typeof(System.Drawing.Image), PackageValueTypes.Image);
_typeValueTypes.Add(typeof(TreePackage), PackageValueTypes.NestedPackage);
_typeValueTypes.Add(typeof(Stream), PackageValueTypes.Stream);
#endregion
#region valueType map Type
_valueTypes = new Dictionary <PackageValueTypes, Type>();
_valueTypes.Add(PackageValueTypes.Boolean, typeof(bool));
_valueTypes.Add(PackageValueTypes.Byte, typeof(byte));
_valueTypes.Add(PackageValueTypes.Char, typeof(char));
_valueTypes.Add(PackageValueTypes.Int16, typeof(short));
_valueTypes.Add(PackageValueTypes.Int32, typeof(int));
_valueTypes.Add(PackageValueTypes.Int64, typeof(long));
_valueTypes.Add(PackageValueTypes.Single, typeof(float));
_valueTypes.Add(PackageValueTypes.Double, typeof(double));
_valueTypes.Add(PackageValueTypes.SByte, typeof(sbyte));
_valueTypes.Add(PackageValueTypes.Decimal, typeof(decimal));
_valueTypes.Add(PackageValueTypes.UInt16, typeof(ushort));
_valueTypes.Add(PackageValueTypes.UInt32, typeof(uint));
_valueTypes.Add(PackageValueTypes.UInt64, typeof(ulong));
_valueTypes.Add(PackageValueTypes.IntPtr, typeof(IntPtr));
_valueTypes.Add(PackageValueTypes.UIntPtr, typeof(UIntPtr));
_valueTypes.Add(PackageValueTypes.DateTime, typeof(DateTime));
_valueTypes.Add(PackageValueTypes.TimeSpan, typeof(TimeSpan));
_valueTypes.Add(PackageValueTypes.String, typeof(string));
_valueTypes.Add(PackageValueTypes.Stream, typeof(Stream));
_valueTypes.Add(PackageValueTypes.Icon, typeof(System.Drawing.Icon));
_valueTypes.Add(PackageValueTypes.Image, typeof(System.Drawing.Image));
_valueTypes.Add(PackageValueTypes.Color, typeof(System.Drawing.Color));
_valueTypes.Add(PackageValueTypes.NestedPackage, typeof(TreePackage));
_valueTypes.Add(PackageValueTypes.Object, typeof(object));
#endregion
#region compressor map handlers
_compressors = new Dictionary <PackageCompressTypes, CompressorHandler>();
_compressors.Add(PackageCompressTypes.QuickLZ, Compressor_QuickLZ);
_compressors.Add(PackageCompressTypes.Gzip, Compressor_Gzip);
_compressors.Add(PackageCompressTypes.Lzma7z, Compressor_Lzma);
//_compressors.Add(PackageCompressTypes.Zlibwapi, (buffer, compress) => compress ? Symbol.IO.Compression.ZlibwapiHelper.Compress(buffer) : Symbol.IO.Compression.ZlibwapiHelper.Decompress(buffer));
_compressors.Add(PackageCompressTypes.NonEncrypt_NonCompress, Compressor_Empty);
#endregion
#region valueType map package SingleData Handler
_packageValueSingleDataHandlers = new Dictionary <PackageValueTypes, PackageValueSingleDataHandler>();
_packageValueSingleDataHandlers.Add(PackageValueTypes.Boolean, (keyEntry, entry) => {
byte[] result = new byte[1];
if ((bool)entry.Value)
{
result[0] = 1;
}
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Byte, (keyEntry, entry) => new byte[] { (byte)entry.Value });
_packageValueSingleDataHandlers.Add(PackageValueTypes.Char, (keyEntry, entry) => {
byte[] result = new byte[2];
char tChar = (char)entry.Value;
Marshal.Copy((IntPtr)(&tChar), result, 0, 2);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Int16, (keyEntry, entry) => {
short tShort = TypeExtensions.Convert <short>(entry.Value, 0);
byte[] result = new byte[2];
Marshal.Copy((IntPtr)(&tShort), result, 0, 2);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Int32, (keyEntry, entry) => {
int tInt32 = TypeExtensions.Convert <int>(entry.Value, 0);
byte[] result = new byte[4];
Marshal.Copy((IntPtr)(&tInt32), result, 0, 4);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Int64, (keyEntry, entry) => {
long tInt64 = TypeExtensions.Convert <long>(entry.Value, 0L);
byte[] result = new byte[8];
Marshal.Copy((IntPtr)(&tInt64), result, 0, 8);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Single, (keyEntry, entry) => {
float tSingle = TypeExtensions.Convert <float>(entry.Value, 0F);
byte[] result = new byte[4];
Marshal.Copy((IntPtr)(&tSingle), result, 0, 4);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Double, (keyEntry, entry) => {
double tDouble = TypeExtensions.Convert <double>(entry.Value, 0D);
byte[] result = new byte[8];
Marshal.Copy((IntPtr)(&tDouble), result, 0, 8);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.SByte, (keyEntry, entry) => {
sbyte tSByte = TypeExtensions.Convert <sbyte>(entry.Value, 0);
byte[] result = new byte[1];
Marshal.Copy((IntPtr)(&tSByte), result, 0, 1);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Decimal, (keyEntry, entry) => Encoding.ASCII.GetBytes(entry.Value.ToString()));
_packageValueSingleDataHandlers.Add(PackageValueTypes.UInt16, (keyEntry, entry) => {
ushort tUShort = TypeExtensions.Convert <ushort>(entry.Value, 0);
byte[] result = new byte[2];
Marshal.Copy((IntPtr)(&tUShort), result, 0, 2);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.UInt32, (keyEntry, entry) => {
uint tUInt32 = TypeExtensions.Convert <uint>(entry.Value, 0);
byte[] result = new byte[4];
Marshal.Copy((IntPtr)(&tUInt32), result, 0, 4);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.UInt64, (keyEntry, entry) => {
ulong tUInt64 = TypeExtensions.Convert <ulong>(entry.Value, 0L);
byte[] result = new byte[8];
Marshal.Copy((IntPtr)(&tUInt64), result, 0, 8);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.IntPtr, (keyEntry, entry) => {
IntPtr tIntPtr = (IntPtr)entry.Value;
byte[] result = new byte[IntPtr.Size];
if (IntPtr.Size == 4)
{
int tIntPtr2 = tIntPtr.ToInt32();
Marshal.Copy((IntPtr)(&tIntPtr2), result, 0, 4);
}
else
{
long tIntPtr3 = tIntPtr.ToInt64();
Marshal.Copy((IntPtr)(&tIntPtr3), result, 0, 8);
}
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.UIntPtr, (keyEntry, entry) => {
UIntPtr tUIntPtr = (UIntPtr)entry.Value;
byte[] result = new byte[UIntPtr.Size];
if (UIntPtr.Size == 4)
{
uint tUIntPtr2 = tUIntPtr.ToUInt32();
Marshal.Copy((IntPtr)(&tUIntPtr2), result, 0, 4);
}
else
{
ulong tUIntPtr3 = tUIntPtr.ToUInt64();
Marshal.Copy((IntPtr)(&tUIntPtr3), result, 0, 8);
}
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.DateTime, (keyEntry, entry) => {
return(Encoding.ASCII.GetBytes(((DateTime)entry.Value).ToString("yyyy-MM-dd HH:mm:ss")));
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.TimeSpan, (keyEntry, entry) => {
double tTimeSpan = ((TimeSpan)entry.Value).TotalMilliseconds;
byte[] result = new byte[8];
Marshal.Copy((IntPtr)(&tTimeSpan), result, 0, 8);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.String, (keyEntry, entry) => Encoding.UTF8.GetBytes((string)entry.Value));
_packageValueSingleDataHandlers.Add(PackageValueTypes.Stream, (keyEntry, entry) => {
MemoryStream memoryStream = entry.Value as MemoryStream;
if (memoryStream != null)
{
return(memoryStream.ToArray());
}
FileStream fileStream = entry.Value as FileStream;
if (fileStream != null)
{
fileStream.Position = 0;
byte[] result = new byte[fileStream.Length];
fileStream.Read(result, 0, result.Length);
return(result);
}
using (memoryStream = new MemoryStream()) {
StreamExtensions.CopyTo(((Stream)entry.Value), memoryStream, true);
return(memoryStream.ToArray());
}
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Icon, (keyEntry, entry) => {
using (MemoryStream memoryStream = new MemoryStream()) {
((System.Drawing.Icon)entry.Value).Save(memoryStream);
return(memoryStream.ToArray());
}
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Image, (keyEntry, entry) => {
using (MemoryStream memoryStream = new MemoryStream()) {
System.Drawing.Image p = (System.Drawing.Image)entry.Value;
p.Save(memoryStream, p.RawFormat);
return(memoryStream.ToArray());
}
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Color, (keyEntry, entry) => {
int tColor = ((System.Drawing.Color)entry.Value).ToArgb();
byte[] result = new byte[4];
Marshal.Copy((IntPtr)(&tColor), result, 0, 4);
return(result);
});
_packageValueSingleDataHandlers.Add(PackageValueTypes.Guid, (keyEntry, entry) => ((Guid)entry.Value).ToByteArray());
_packageValueSingleDataHandlers.Add(PackageValueTypes.NestedPackage, (keyEntry, entry) => ((TreePackage)entry.Value).Save());
_packageValueSingleDataHandlers.Add(PackageValueTypes.Object, (keyEntry, entry) => {
Type type = entry.Value.GetType();
if (AttributeExtensions.IsDefined <NonPackageAttribute>(type) || AttributeExtensions.IsDefined <Formatting.IgnoreAttribute>(type))
{
return(new byte[0]);
}
ICustomPackage customPackage = null;
byte flag;
if (AttributeExtensions.IsDefined <PropertyPackageAttribute>(type))
{
customPackage = PropertyPackage.Instance;
flag = 0;
}
else if (AttributeExtensions.IsDefined <FieldPackageAttribute>(type))
{
customPackage = FieldPackage.Instance;
flag = 1;
}
else if (AttributeExtensions.IsDefined <CustomPackageAttribute>(type))
{
var attribute = AttributeExtensions.GetCustomAttribute <CustomPackageAttribute>(type);
customPackage = FastWrapper.CreateInstance <ICustomPackage>(attribute.CustomPackageType);
//customPackage= CustomPackageAttribute.GetCustomPackageType(type);
flag = 255;
}
else
{
customPackage = PropertyPackage.Instance;
flag = 0;
}
using (MemoryStream stream = new MemoryStream(128)) {
stream.WriteByte(flag);
byte[] buffer = null;
if (flag == 255)
{
buffer = Encoding.UTF8.GetBytes(customPackage.GetType().AssemblyQualifiedName);
short iShort = (short)buffer.Length;
byte[] buffer2 = new byte[2];
Marshal.Copy((IntPtr)(&iShort), buffer2, 0, 2);
stream.Write(buffer2, 0, buffer2.Length);
stream.Write(buffer, 0, buffer.Length);
}
buffer = customPackage.Save(entry.Value);
stream.Write(buffer, 0, buffer.Length);
return(stream.ToArray());
}
});
#endregion
#region valueType map unpackage SingleData Handler
_unPakcageValueSingleDataHandlers = new Dictionary <PackageValueTypes, UnPackageValueSingleDataHandler>();
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Boolean, (keyEntry, entry, buffer) => entry.Value = buffer[0] == 1);
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Byte, (keyEntry, entry, buffer) => entry.Value = buffer[0]);
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Char, (keyEntry, entry, buffer) => {
char tChar;;
Marshal.Copy(buffer, 0, (IntPtr)(&tChar), 2);
entry.Value = tChar;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Int16, (keyEntry, entry, buffer) => {
short tShort;
Marshal.Copy(buffer, 0, (IntPtr)(&tShort), 2);
entry.Value = tShort;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Int32, (keyEntry, entry, buffer) => {
int tInt32;
Marshal.Copy(buffer, 0, (IntPtr)(&tInt32), 4);
entry.Value = tInt32;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Int64, (keyEntry, entry, buffer) => {
long tInt64;
Marshal.Copy(buffer, 0, (IntPtr)(&tInt64), 8);
entry.Value = tInt64;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Single, (keyEntry, entry, buffer) => {
float tSingle;
Marshal.Copy(buffer, 0, (IntPtr)(&tSingle), 4);
entry.Value = tSingle;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Double, (keyEntry, entry, buffer) => {
double tDouble;
Marshal.Copy(buffer, 0, (IntPtr)(&tDouble), 8);
entry.Value = tDouble;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.SByte, (keyEntry, entry, buffer) => {
sbyte tSByte;
Marshal.Copy(buffer, 0, (IntPtr)(&tSByte), 1);
entry.Value = tSByte;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Decimal, (keyEntry, entry, buffer) => entry.Value = decimal.Parse(Encoding.ASCII.GetString(buffer)));
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.UInt16, (keyEntry, entry, buffer) => {
ushort tUShort;
Marshal.Copy(buffer, 0, (IntPtr)(&tUShort), 2);
entry.Value = tUShort;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.UInt32, (keyEntry, entry, buffer) => {
uint tUInt32;
Marshal.Copy(buffer, 0, (IntPtr)(&tUInt32), 4);
entry.Value = tUInt32;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.UInt64, (keyEntry, entry, buffer) => {
ulong tUInt64;
Marshal.Copy(buffer, 0, (IntPtr)(&tUInt64), 8);
entry.Value = tUInt64;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.IntPtr, (keyEntry, entry, buffer) => {
IntPtr tIntPtr;
if (buffer.Length == 4)
{
int tIntPtr2;
Marshal.Copy(buffer, 0, (IntPtr)(&tIntPtr2), 4);
tIntPtr = new IntPtr(tIntPtr2);
}
else
{
long tIntPtr3;
Marshal.Copy(buffer, 0, (IntPtr)(&tIntPtr3), 8);
tIntPtr = new IntPtr(tIntPtr3);
}
entry.Value = tIntPtr;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.UIntPtr, (keyEntry, entry, buffer) => {
UIntPtr tUIntPtr;
if (buffer.Length == 4)
{
uint tUIntPtr2;
Marshal.Copy(buffer, 0, (IntPtr)(&tUIntPtr2), 4);
tUIntPtr = new UIntPtr(tUIntPtr2);
}
else
{
ulong tUIntPtr3;
Marshal.Copy(buffer, 0, (IntPtr)(&tUIntPtr3), 8);
tUIntPtr = new UIntPtr(tUIntPtr3);
}
entry.Value = tUIntPtr;
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.DateTime, (keyEntry, entry, buffer) => entry.Value = DateTime.Parse(Encoding.ASCII.GetString(buffer)));
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.TimeSpan, (keyEntry, entry, buffer) => {
double tTimeSpan;
Marshal.Copy(buffer, 0, (IntPtr)(&tTimeSpan), 8);
entry.Value = TimeSpan.FromMilliseconds(tTimeSpan);
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.String, (keyEntry, entry, buffer) => entry.Value = Encoding.UTF8.GetString(buffer));
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Stream, (keyEntry, entry, buffer) => entry.Value = new MemoryStream(buffer));
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Icon, (keyEntry, entry, buffer) => {
using (MemoryStream memoryStream = new MemoryStream(buffer)) {
entry.Value = new System.Drawing.Icon(memoryStream);
}
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Image, (keyEntry, entry, buffer) => {
using (MemoryStream memoryStream = new MemoryStream(buffer)) {
entry.Value = System.Drawing.Image.FromStream(memoryStream);
}
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Color, (keyEntry, entry, buffer) => {
int tColor;
Marshal.Copy(buffer, 0, (IntPtr)(&tColor), 4);
entry.Value = System.Drawing.Color.FromArgb(tColor);
});
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Guid, (keyEntry, entry, buffer) => entry.Value = new Guid(buffer));
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.NestedPackage, (keyEntry, entry, buffer) => entry.Value = Load(buffer));
_unPakcageValueSingleDataHandlers.Add(PackageValueTypes.Object, (keyEntry, entry, buffer) => {
if (buffer.Length == 0)//NonPackage
{
return;
}
using (MemoryStream stream = new MemoryStream(buffer)) {
byte flag = (byte)stream.ReadByte();
ICustomPackage customPackage = null;
byte[] buffer2;
if (flag == 0)
{
customPackage = PropertyPackage.Instance;
}
else if (flag == 1)
{
customPackage = FieldPackage.Instance;
}
else if (flag == 255)
{
short iShort;
buffer2 = new byte[2];
stream.Read(buffer2, 0, 2);
Marshal.Copy(buffer2, 0, (IntPtr)(&iShort), 2);
buffer2 = new byte [iShort];
stream.Read(buffer2, 0, iShort);
string typeFullName = Encoding.UTF8.GetString(buffer2);
Type customType = FastWrapper.GetWarpperType(typeFullName);
if (customType == null)
{
throw new TypeLoadException("未能找到类型“" + typeFullName + "”");
}
customPackage = (ICustomPackage)FastWrapper.CreateInstance(customType);
}
else
{
throw new NotSupportedException();
}
//read to end
buffer2 = new byte[stream.Length - stream.Position];
stream.Read(buffer2, 0, buffer2.Length);
entry.Value = customPackage.Load(buffer2);
}
});
#endregion
}
