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