private static void SetUseUnsafeHeaderParsing()
{
System.Type type = FastWrapper.GetWarpperType("System.Net.Configuration.SettingsSectionInternal,System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
if (type == null)
{
return;
}
object instance = FastWrapper.Get(type, "Section");
if (instance == null)
{
return;
}
FastWrapper.Set(instance, "useUnsafeHeaderParsing", true);
}
/// <summary>
/// 获取 PostgreSQL.Data 类型
/// </summary>
/// <param name="typeFullName">类型全名。</param>
/// <param name="throw">是否报错</param>
/// <returns></returns>
public static System.Type GetType(string typeFullName, bool @throw = false)
{
if (string.IsNullOrEmpty(typeFullName))
{
return(null);
}
System.Type type = _types[typeFullName];
if (type == null)
{
string typeName = typeFullName + ", Npgsql";
type = FastWrapper.GetWarpperType(typeName, "Npgsql.dll");
if (type == null && @throw)
{
CommonException.ThrowTypeLoad(typeName);
}
_types[typeFullName] = type;
}
return(type);
}
static void UnPackageValueDictionary(KeyEntry keyEntry, Entry entry, byte[] buffer)
{
TreePackage package = Load(buffer);
if (package == null || package.Count == 0)
{
entry.Value = new System.Collections.Hashtable();
return;
}
bool isGeneric = (bool)package.Attributes["IsGeneric"];
System.Collections.IDictionary result = null;
if (isGeneric)
{
Type t1 = FastWrapper.GetWarpperType((string)package.Attributes["T1"]);
Type t2 = FastWrapper.GetWarpperType((string)package.Attributes["T2"]);
object comparer = FastWrapper.Get(typeof(System.Collections.Generic.EqualityComparer <>).MakeGenericType(t1), "Default");
if (package.Attributes.ContainsKey("KeyIsString") && (bool)package.Attributes["KeyIsString"])
{
comparer = (bool)package.Attributes["ComparerIgnoreCase"] ? StringComparer.OrdinalIgnoreCase : StringComparer.Ordinal;
}
result = (System.Collections.IDictionary)FastWrapper.CreateInstance(typeof(System.Collections.Generic.Dictionary <,>).MakeGenericType(t1, t2), package.Count, comparer);
}
else
{
result = new System.Collections.Hashtable(package.Count);
}
Entry entry2 = null;
for (int index = 0; index < package.Count; index++)
{
entry2 = package.Entries[index.ToString()];
result.Add(entry2.Attributes["Key"], entry2.Value);
}
entry.Value = result;
}
public object Load(byte[] buffer)
{
TreePackage package = TreePackage.Load(buffer);
if (!package.Attributes.ContainsKey("Type"))
{
return(null);
}
Type type = FastWrapper.GetWarpperType((string)package.Attributes["Type"]);
if (type == null)
{
throw new TypeMismatchException("未能找到类型“" + (string)package.Attributes["Type"] + "”");
}
//bool isAnonymousType = type.IsAnonymousType();
//if (isAnonymousType) {
// ConstructorInfo ctorX = type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic)[0];
// ParameterInfo[] @paramsX = ctorX.GetParameters();
// object[] argsX = new object[@paramsX.Length];
// for (int i = 0; i < @paramsX.Length; i++) {
// argsX[i] = package[@paramsX[i].Name];
// }
// return FastWrapper.CreateInstance(type, argsX);
//}
ConstructorInfo[] ctors = type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance | BindingFlags.Instance);
object[] args = null;
if (ctors.Length > 0)
{
ConstructorInfo ctor = ctors[0];
ParameterInfo[] @params = ctor.GetParameters();
args = new object[@params.Length];
for (int i = 0; i < @params.Length; i++)
{
string key = null;
foreach (string k in package.Keys)
{
if (k.Equals(@params[i].Name, StringComparison.OrdinalIgnoreCase))
{
key = k;
}
}
args[i] = package[key];
package.Remove(key);
}
}
else
{
args = new object[0];
}
object result = FastWrapper.CreateInstance(type, args);
foreach (string key in package.Keys)
{
PropertyInfo property = type.GetProperty(key, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
if (property == null)
{
FieldInfo field = type.GetField(key, BindingFlags.Public | BindingFlags.Instance);
if (field != null)
{
field.SetValue(result, package[key]);
}
continue;
}
//try {
if (property.CanWrite)
{
property.SetValue(result, TypeExtensions.Convert(package[key], property.PropertyType), null);
}
//} catch(Exception e){
// throw new Exception(string.Format("key={0},name={1},type:{2},{3}", key, property.Name, type.FullName,e.Message));
//}
}
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
}
public object Load(byte[] buffer)
{
TreePackage package = TreePackage.Load(buffer);
if (!package.Attributes.ContainsKey("Type"))
{
return(null);
}
Type type = FastWrapper.GetWarpperType((string)package.Attributes["Type"]);
if (type == null)
{
CommonException.ThrowTypeMismatch("未能找到类型“" + (string)package.Attributes["Type"] + "”");
}
//bool isAnonymousType = type.IsAnonymousType();
//if (isAnonymousType) {
// ConstructorInfo ctorX = type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic)[0];
// ParameterInfo[] @paramsX = ctorX.GetParameters();
// object[] argsX = new object[@paramsX.Length];
// for (int i = 0; i < @paramsX.Length; i++) {
// argsX[i] = package[@paramsX[i].Name];
// }
// return FastWrapper.CreateInstance(type, argsX);
//}
ConstructorInfo[] ctors = type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.CreateInstance | BindingFlags.Instance);
object[] args = null;
if (ctors.Length > 0)
{
ConstructorInfo ctor = ctors[0];
ParameterInfo[] @params = ctor.GetParameters();
args = new object[@params.Length];
for (int i = 0; i < @params.Length; i++)
{
string key = null;
foreach (string k in package.Keys)
{
if (k.Equals(@params[i].Name, StringComparison.OrdinalIgnoreCase) || k.EndsWith(@params[i].Name, StringComparison.OrdinalIgnoreCase))
{
key = k;
}
}
if (string.IsNullOrEmpty(key))
{
return(null);
}
args[i] = package[key];
package.Remove(key);
}
}
else
{
args = new object[0];
}
object result = FastWrapper.CreateInstance(type, args);
foreach (string key in package.Keys)
{
FieldInfo field = type.GetField(key, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (field != null)
{
field.SetValue(result, TypeExtensions.Convert(package[key], field.FieldType));
}
}
return(result);
}
static void UnPackageValueIEnumerable(KeyEntry keyEntry, Entry entry, byte[] buffer, TreePackage treePackage)
{
if (treePackage.Version == 2)
{
if (entry.ArrayType == PackageArrayTypes.T_Array && entry.ValueType == PackageValueTypes.Byte)
{
entry.Value = buffer;
return;
}
}
TreePackage package = Load(buffer);
Type t1 = null;
if (package.Attributes.ContainsKey("T1"))
{
t1 = FastWrapper.GetWarpperType((string)package.Attributes["T1"]);
}
UnPackageValueIEnumerableCreateArrayHandler createArrayHandler = null;
UnPackageValueIEnumerableArrayAddHandler addHandler = null;
System.Collections.IList array = null;
Array array2 = null;
switch (keyEntry.ArrayType)
{
case PackageArrayTypes.T_Array:
createArrayHandler = (p1) => array2 = (Array)CreateTArray(keyEntry, p1, false, true, t1);
addHandler = (p1, p2) => array2.SetValue(p2, p1);
break;
case PackageArrayTypes.T_List:
createArrayHandler = (p1) => CreateTArray(keyEntry, p1, true, true, t1);
addHandler = (p1, p2) => array.Add(p2);
break;
case PackageArrayTypes.Object_Array:
createArrayHandler = (p1) => array2 = (Array)CreateTArray(keyEntry, p1, false, false, t1);
addHandler = (p1, p2) => array2.SetValue(p2, p1);
break;
case PackageArrayTypes.Object_List:
createArrayHandler = (p1) => CreateTArray(keyEntry, p1, true, false, t1);
addHandler = (p1, p2) => array.Add(p2);
break;
default:
throw new NotSupportedException("暂不支持“" + keyEntry.ArrayType + "”类型的数组。");
}
if (package == null || package.Count == 0)
{
entry.Value = createArrayHandler(0);//创建实际的数组类型
return;
}
//创建数组
array = createArrayHandler(package.Count);
for (int index = 0; index < package.Count; index++)
{
addHandler(index, package[index.ToString()]);
}
entry.Value = array;
package.Clear(false);
package.Dispose();
package = null;
}
