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 }