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);
}
}
