/// <summary>
///
/// </summary>
/// <param name="type1"></param>
/// <returns></returns>
private CompactSerializeCache GetCompactSerializeCache(Type type1)
{
lock (this._dicCache)
{
if (this._dicCache.ContainsKey(type1))
{
return(this._dicCache[type1]);
}
FieldInfo[] fields = type1.GetFields(BindingFlags.GetField | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
List <FieldInfo> list = new List <FieldInfo>();
foreach (FieldInfo info in fields)
{
NonSerializedAttribute[] customAttributes = (NonSerializedAttribute[])info.GetCustomAttributes(typeof(NonSerializedAttribute), false);
if ((customAttributes == null) || (customAttributes.Length == 0))
{
list.Add(info);
}
}
if (_ComparisonFieldInfo == null)
{
_ComparisonFieldInfo = new Comparison <FieldInfo>(CompactFieldSerializer.CompareToName);
}
list.Sort(_ComparisonFieldInfo);
CompactSerializeCache cache = new CompactSerializeCache(list.ToArray());
this._dicCache.Add(type1, cache);
return(cache);
}
}
/// <summary>
///
/// </summary>
/// <param name="baseType"></param>
/// <param name="type"></param>
/// <param name="buff"></param>
/// <param name="offset"></param>
/// <returns></returns>
protected override object DoDeserializeComplicatedType(Type baseType, Type type, byte[] buff, ref int offset)
{
int num = ByteConverter.Parse <int>(buff, ref offset);
object obj2 = null;
if (num > -1)
{
obj2 = Activator.CreateInstance(type);
Type singleType = base.GetBaseType(type);
if (base.IsGenericTypeList(singleType))//继承List<>类
{
IList list = base.DeserializeList(baseType, buff, ref offset, singleType, num);
foreach (object item in list)
{
((IList)obj2).Add(item);
}
}
else if (base.IsGenericTypeDictionary(singleType))//继承List<>类
{
IDictionary list = base.DeserializeDictionary(baseType, buff, ref offset, singleType, num);
foreach (object keys in list.Keys)
{
((IDictionary)obj2).Add(keys, list[keys]);
}
}
else if (singleType.IsArray)//继承Array类型
{
obj2 = base.DeserializeArray(baseType, buff, ref offset, singleType, num);
}
else
{
CompactSerializeCache cache = this.GetCompactSerializeCache(type);
for (int i = 0; i < cache.FieldArray.Length; i++)
{
object val = base.DoDeserialize(baseType, cache.FieldArray[i].FieldType, string.Empty, buff, ref offset);
ReflectionHelper.SetFieldValue(obj2, cache.FieldArray[i].Name, val);
}
}
}
return(obj2);
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <param name="obj"></param>
/// <param name="stream"></param>
protected override void DoSerializeComplicatedType(Type type, object obj, MemoryStream stream)
{
if (obj == null)
{
byte[] buffer = ByteConverter.ToBytes <int>(-1);
stream.Write(buffer, 0, buffer.Length);
}
else
{
Type baseType = base.GetBaseType(type);
if (base.IsGenericTypeList(baseType))//继承List<>类
{
base.SerializeList(stream, obj, baseType);
}
else if (base.IsGenericTypeDictionary(baseType))
{
base.SerializeDictionary(stream, obj, baseType);
}
else if (baseType.IsArray)
{
base.SerializeArray(stream, obj, baseType);
}
else
{
CompactSerializeCache cache = this.GetCompactSerializeCache(type);
MemoryStream stream2 = new MemoryStream();
for (int i = 0; i < cache.FieldArray.Length; i++)
{
object fieldValue = ReflectionHelper.GetFieldValue(obj, cache.FieldArray[i].Name);
base.DoSerialize(stream2, cache.FieldArray[i].FieldType, fieldValue);
}
byte[] buffer2 = stream2.ToArray();
byte[] buffer3 = ByteConverter.ToBytes <int>(buffer2.Length);
stream.Write(buffer3, 0, buffer3.Length);
stream.Write(buffer2, 0, buffer2.Length);
}
}
}