/// <summary>
///
/// </summary>
/// <param name="type1"></param>
/// <returns></returns>
private CompactPropertySerializeCache GetSerializeCache(Type type1)
{
lock (this._dicCache)
{
if (this._dicCache.ContainsKey(type1))
{
return(this._dicCache[type1]);
}
IPropertyQuicker quicker = PropertyQuickerFactory.CreatePropertyQuicker(type1);
List <PropertyInfo> list = new List <PropertyInfo>();
foreach (PropertyInfo info in type1.GetProperties())
{
if (info.CanRead && info.CanWrite)
{
list.Add(info);
}
}
if (_ComparisonProperty == null)
{
_ComparisonProperty = new Comparison <PropertyInfo>(CompactPropertySerializer.CompareToName);
}
list.Sort(_ComparisonProperty);
CompactPropertySerializeCache cache = new CompactPropertySerializeCache(quicker, 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 offset3 = 37;
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
{
CompactPropertySerializeCache cache = this.GetSerializeCache(type);
for (int i = 0; i < cache.PropertyArray.Length; i++)
{
object obj3 = base.DoDeserialize(baseType, cache.PropertyArray[i].PropertyType, string.Empty, buff, ref offset);
this.SetPropertyValue(type, cache.PropertyQuicker, obj2, cache.PropertyArray[i].Name, obj3);
}
}
}
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
{
CompactPropertySerializeCache cache = this.GetSerializeCache(type);
MemoryStream stream2 = new MemoryStream();
for (int i = 0; i < cache.PropertyArray.Length; i++)
{
object obj2 = cache.PropertyQuicker.GetValue(obj, cache.PropertyArray[i].Name);
base.DoSerialize(stream2, cache.PropertyArray[i].PropertyType, obj2);
}
byte[] buffer2 = stream2.ToArray();
byte[] buffer3 = ByteConverter.ToBytes <int>(buffer2.Length);
stream.Write(buffer3, 0, buffer3.Length);
stream.Write(buffer2, 0, buffer2.Length);
}
}
}
