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()); }
byte[] PackageValueDictionary(KeyEntry keyEntry, Entry entry, Type type) { bool isGeneric = IsTheTypes(type, typeof(System.Collections.Generic.IDictionary <,>)); TreePackage package = new TreePackage(); package.Attributes.Add("IsGeneric", isGeneric); if (isGeneric) { Type[] types = GetTheTypes(type, typeof(System.Collections.Generic.IDictionary <,>)).GetGenericArguments(); package.Attributes.Add("T1", types[0].AssemblyQualifiedName); package.Attributes.Add("T2", types[1].AssemblyQualifiedName); Type typeX = GetTheTypes(type, typeof(System.Collections.Generic.Dictionary <,>)); if (typeX != null && typeX.GetGenericArguments()[0] == typeof(string)) { package.Attributes.Add("KeyIsString", true); System.Collections.Generic.IEqualityComparer <string> comparer = (System.Collections.Generic.IEqualityComparer <string>)FastWrapper.Get(entry.Value, "Comparer"); package.Attributes.Add("ComparerIgnoreCase", (comparer == StringComparer.CurrentCultureIgnoreCase || comparer == StringComparer.InvariantCultureIgnoreCase || comparer == StringComparer.OrdinalIgnoreCase)); } } int index = -1; foreach (object item in (System.Collections.IEnumerable)entry.Value) { index++; package.Add(index.ToString(), FastWrapper.Get(item, "Value")); Entry itemEntry = package.Entries[index.ToString()]; itemEntry.Attributes.Add("Key", FastWrapper.Get(item, "Key")); } return(package.Save()); }
static void UnPackageValueNameValueCollection(KeyEntry keyEntry, Entry entry, byte[] buffer) { TreePackage package = Load(buffer); if (package == null || package.Count == 0) { entry.Value = new System.Collections.Specialized.NameValueCollection();//创建实际的数组类型 return; } System.Collections.Specialized.NameValueCollection col = new System.Collections.Specialized.NameValueCollection(); Entry entry2 = null; for (int index = 0; index < package.Count; index++) { entry2 = package.Entries[index.ToString()]; string key = (string)entry2.Attributes["Key"]; if (entry2.Value != null) { foreach (string item in (string[])entry2.Value) { col.Add(key, item); } } } entry.Value = col; package.Clear(false); package.Dispose(); package = null; }
/// <summary> /// 释放树型包所占用的资源 /// </summary> /// <param name="disposing">是否为终结。</param> protected virtual void Dispose(bool disposing) { if (disposing) { if (_entries != null) { Clear(); _entries = null; } if (_entryList != null) { _entryList.Dispose(); _entryList = null; } if (_comment == null) { _comment = null; } if (_attributes != null) { _attributes.Dispose(); _attributes = null; } GC.SuppressFinalize(this); //GC.Collect(0); //GC.Collect(); } }
public void Dispose() { if (_package != null) { _package = null; } GC.SuppressFinalize(this); //GC.Collect(0); //GC.Collect(); }
byte[] PackageValueNameValueCollection(KeyEntry keyEntry, Entry entry, Type type) { TreePackage package = new TreePackage(); System.Collections.Specialized.NameValueCollection col = (System.Collections.Specialized.NameValueCollection)entry.Value; for (int i = 0; i < col.Count; i++) { package.Add(i.ToString(), col.GetValues(i)); package.Entries[i.ToString()].Attributes.Add("Key", col.GetKey(i)); } return(package.Save()); }
/// <summary> /// 释放占用的资源。 /// </summary> /// <param name="disposing">是否为终结。</param> protected void Dispose(bool disposing) { if (disposing) { if (_key != null) { _key = null; } if (_value != null) { _value = null; } if (_attributes != null) { _attributes.Dispose(); _attributes = null; } GC.SuppressFinalize(this); //GC.Collect(0); //GC.Collect(); } }
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 EntryList(TreePackage package) { _package = package; }
byte[] PackageValueIEnumerable(KeyEntry keyEntry, Entry entry, Type type) { if (Version == 2) { if (entry.ArrayType == PackageArrayTypes.T_Array && entry.ValueType == PackageValueTypes.Byte) { byte[] buffer1 = entry.Value as byte[]; if (buffer1 != null) { return(buffer1); } IEnumerable <byte> buffer2 = entry.Value as IEnumerable <byte>; if (buffer2 != null) { buffer1 = LinqHelper.ToArray(buffer2); if (buffer1 == null) { return(new byte[0]); } return(buffer1); } IEnumerator <byte> buffer3 = entry.Value as IEnumerator <byte>; if (buffer3 != null) { using (buffer3) { List <byte> buffer3_x = new List <byte>(); while (buffer3.MoveNext()) { buffer3_x.Add(buffer3.Current); } return(buffer3_x.ToArray()); } } return(new byte[0]); } } TreePackage package = new TreePackage(); if (entry.ArrayType == PackageArrayTypes.T_Array || entry.ArrayType == PackageArrayTypes.T_List) { if (entry.ValueType == PackageValueTypes.Object) { Type t1 = null; if (entry.ArrayType == PackageArrayTypes.T_Array) { t1 = entry.Value.GetType().GetElementType(); } else { t1 = entry.Value.GetType(); if (t1.GetGenericArguments().Length == 0) { t1 = null; } else { t1 = t1.GetGenericArguments()[0]; } } if (t1 != null) { package.Attributes.Add("T1", t1.AssemblyQualifiedName); } } } int index = -1; if (IsTheTypes(type, typeof(System.Collections.IEnumerable))) { foreach (object item in (System.Collections.IEnumerable)entry.Value) { index++; package.Add(index.ToString(), item); } } else { System.Collections.IEnumerator enumerator = (System.Collections.IEnumerator)entry.Value; System.Collections.Generic.List <object> list = new System.Collections.Generic.List <object>(); while (enumerator.MoveNext()) { index++; package.Add(index.ToString(), enumerator.Current); list.Add(enumerator.Current); } IDisposable disp = enumerator as IDisposable; if (disp != null) { disp.Dispose(); } disp = null; enumerator = null; entry.Value = list; } return(package.Save()); }
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); }
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; }
/// <summary> /// 加载数据 /// </summary> /// <param name="reader">树型包读取器实例</param> /// <param name="password">密码,为空将会是默认密码。</param> /// <returns>返回加载后的树型包实例。</returns> public static unsafe TreePackage Load(System.IO.Stream reader, byte[] password = null) { //if (reader == null) // throw new ArgumentNullException("reader", "树型包读取器不能为 null 。"); if (reader == null) { return(null); } if (!reader.CanRead) { throw new ArgumentNullException("reader", "树型包读取器不能进行读取操作。"); } //if (reader.Closed) // throw new ObjectDisposedException("reader", "树型包读取器已经关闭。"); #region header 1 byte[] buffer = new byte[8]; if (reader.Read(buffer, 0, 4) != 4) //位数不够 { return(null); } //错误的标识 if (buffer[0] != HeaderEntry.StartFlag[0] || buffer[1] != HeaderEntry.StartFlag[1] || buffer[2] != HeaderEntry.StartFlag[2] || buffer[3] != HeaderEntry.StartFlag[3]) { return(null); } HeaderEntry packageEntry = new HeaderEntry(); packageEntry.Started = true; //Version,EncryptType if (reader.Read(buffer, 0, 2) != 2) { return(null); } if (buffer[0] > 9) { packageEntry.Version = (byte)(buffer[0] / 10); buffer[0] -= (byte)(packageEntry.Version * 10); } packageEntry.EncryptType = (PackageEncryptTypes)buffer[0]; //KeyIgnoreCase,HasAttributes,HasComment if (buffer[1] >= 100) { packageEntry.KeyIgnoreCase = true; buffer[1] -= 100; } if (buffer[1] >= 10) { packageEntry.HasAttributes = true; buffer[1] -= 10; } if (buffer[1] == 1) { packageEntry.HasComment = true; } #endregion if (password == null || password.Length == 0 || password == _defaultBinaryWavePassword) { password = _defaultBinaryWavePassword; if (packageEntry.EncryptType != PackageEncryptTypes.BinaryWave_EmptyPassword) { packageEntry.EncryptType = PackageEncryptTypes.BinaryWave_DefaultPassword; } } else { if (packageEntry.EncryptType != PackageEncryptTypes.BinaryWave_EmptyPassword) { packageEntry.EncryptType = PackageEncryptTypes.BinaryWave_CustomPassword; } } TreePackage result = null; using (Symbol.Encryption.BinaryEncryptionStream binaryEncryptionStream = new Symbol.Encryption.BinaryEncryptionStream(reader, password, packageEntry.EncryptType == PackageEncryptTypes.BinaryWave_EmptyPassword)) { int int32Var; #region header 2 //AttributesLength if (packageEntry.HasAttributes) { if (binaryEncryptionStream.Read(buffer, 0, 4) != 4) { return(null); } Marshal.Copy(buffer, 0, (IntPtr)(&int32Var), 4); packageEntry.AttributesLength = int32Var; } //CommentLength if (packageEntry.HasComment) { if (binaryEncryptionStream.Read(buffer, 0, 4) != 4) { return(null); } Marshal.Copy(buffer, 0, (IntPtr)(&int32Var), 4); packageEntry.CommentLength = int32Var; } //KeysCount if (binaryEncryptionStream.Read(buffer, 0, 4) != 4) { return(null); } Marshal.Copy(buffer, 0, (IntPtr)(&int32Var), 4); packageEntry.KeysCount = int32Var; //AttributesData if (packageEntry.HasAttributes) { packageEntry.AttributesData = new byte[packageEntry.AttributesLength]; if (binaryEncryptionStream.Read(packageEntry.AttributesData, 0, packageEntry.AttributesLength) != packageEntry.AttributesLength) { return(null); } } //CommentData if (packageEntry.HasComment) { packageEntry.CommentData = new byte[packageEntry.CommentLength]; if (binaryEncryptionStream.Read(packageEntry.CommentData, 0, packageEntry.CommentLength) != packageEntry.CommentLength) { return(null); } } #endregion result = new TreePackage(packageEntry); #region Keys //Keys ushort uShortVar = 0; ulong uInt64Var = 0; KeyEntry keyEntry; byte[] bufferValueData = null; Entry entry = null; for (int keyIndex = 0; keyIndex < packageEntry.KeysCount; keyIndex++) { #region Header if (binaryEncryptionStream.Read(buffer, 0, 5) != 5) { return(null); } //KeyLength Marshal.Copy(buffer, 0, (IntPtr)(&uShortVar), 2); keyEntry = new KeyEntry(); keyEntry.KeyLength = uShortVar; if (keyEntry.KeyLength == 0) { return(null); } //ValueType keyEntry.ValueType = (PackageValueTypes)buffer[2]; //Nullable|ArrayType if (buffer[3] >= 100) { keyEntry.Nullable = true; buffer[3] -= 100; } keyEntry.ArrayType = (PackageArrayTypes)buffer[3]; //HasAttributes,CompressType if (buffer[4] >= 100) { keyEntry.HasAttributes = true; buffer[4] -= 100; } keyEntry.CompressType = (PackageCompressTypes)buffer[4]; if (keyEntry.HasAttributes) //AttributesLength { if (binaryEncryptionStream.Read(buffer, 0, 4) != 4) { return(null); } Marshal.Copy(buffer, 0, (IntPtr)(&int32Var), 4); keyEntry.AttributesLength = int32Var; } //ValueDataLength if (!keyEntry.Nullable) { if (binaryEncryptionStream.Read(buffer, 0, 4) != 4) { return(null); } Marshal.Copy(buffer, 0, (IntPtr)(&int32Var), 4); keyEntry.ValueDataLength = int32Var; //CRC32 if (binaryEncryptionStream.Read(buffer, 0, 8) != 8) { return(null); } Marshal.Copy(buffer, 0, (IntPtr)(&uInt64Var), 8); keyEntry.CRC32 = uInt64Var; } #endregion #region Data //KeyData keyEntry.KeyData = new byte[keyEntry.KeyLength]; if (binaryEncryptionStream.Read(keyEntry.KeyData, 0, keyEntry.KeyLength) != keyEntry.KeyLength) { return(null); } //AttributesData if (keyEntry.HasAttributes) { keyEntry.AttributesData = new byte[keyEntry.AttributesLength]; if (binaryEncryptionStream.Read(keyEntry.AttributesData, 0, keyEntry.AttributesLength) != keyEntry.AttributesLength) { return(null); } } entry = new Entry(keyEntry); ((IEntry)entry).SetIsAdd(false); //ValueData if (!keyEntry.Nullable) { bufferValueData = new byte[keyEntry.ValueDataLength]; if (keyEntry.CompressType == PackageCompressTypes.NonEncrypt_NonCompress) { if (binaryEncryptionStream.BaseRead(bufferValueData, 0, keyEntry.ValueDataLength) != keyEntry.ValueDataLength) { return(null); } } else { if (binaryEncryptionStream.Read(bufferValueData, 0, keyEntry.ValueDataLength) != keyEntry.ValueDataLength) { return(null); } } uInt64Var = Symbol.Encryption.CRC32EncryptionHelper.Encrypt(bufferValueData); if (uInt64Var != keyEntry.CRC32) { throw new System.IO.InvalidDataException(string.Format("“{0}”的CRC32数据验证失败。应为:{1:X8},实际:{2:X8}", entry.Key, keyEntry.CRC32, uInt64Var)); } UnPackageValueData(keyEntry, entry, bufferValueData, result); } else { entry.Value = null; } #endregion bufferValueData = null; result.Add(entry); } #endregion } return(result); }
static void UnPackageValueArrayData(KeyEntry keyEntry, Entry entry, byte[] buffer, TreePackage treePackage) { switch (keyEntry.ArrayType) { case PackageArrayTypes.Dictionary: UnPackageValueDictionary(keyEntry, entry, buffer); break; case PackageArrayTypes.NameValueCollection: UnPackageValueNameValueCollection(keyEntry, entry, buffer); break; default: UnPackageValueIEnumerable(keyEntry, entry, buffer, treePackage); break; } }
static void UnPackageValueData(KeyEntry keyEntry, Entry entry, byte[] buffer, TreePackage treePackage) { if (keyEntry.CompressType != PackageCompressTypes.None) { if (!_compressors.ContainsKey(keyEntry.CompressType)) { throw new NotSupportedException("暂不支持“" + keyEntry.CompressType + "”压缩算法。"); } buffer = _compressors[keyEntry.CompressType](buffer, false); } if (keyEntry.ArrayType == PackageArrayTypes.None) { if (!_unPakcageValueSingleDataHandlers.ContainsKey(keyEntry.ValueType)) { throw new NotSupportedException("暂时不支持“" + keyEntry.ValueType + "”类型。"); } _unPakcageValueSingleDataHandlers[keyEntry.ValueType](keyEntry, entry, buffer); } else { UnPackageValueArrayData(keyEntry, entry, buffer, treePackage); } }