/// <summary>
/// 对象反序列化
/// </summary>
/// <param name="deSerializer">二进制数据反序列化</param>
/// <param name="value">数据对象</param>
private void deSerializeTcpServer(DeSerializer deSerializer, ref valueType value)
{
if (deSerializer.CheckMemberCount(memberCountVerify))
{
fixedMemberDeSerializer(deSerializer, ref value);
deSerializer.Read += fixedFillSize;
if (memberDeSerializer != null)
{
memberDeSerializer(deSerializer, ref value);
}
if (isJson || jsonMemberMap != null)
{
deSerializer.ParseJson(ref value);
}
}
else
{
deSerializer.State = DeSerializeState.MemberMap;
}
}
/// <summary>
/// 反序列化
/// </summary>
/// <param name="deSerializer"></param>
/// <param name="value"></param>
public void DeSerialize(DeSerializer deSerializer, ref valueType value)
{
object objectValue = value;
foreach (DeSerializeField field in fields)
{
if (field.Field.IsStatic)
{
field.DeSerializeMethod(deSerializer, AutoCSer.Emit.ConstructorAttribute.GetDefault(field.Field.FieldType));
}
else
{
object fieldValue = field.Field.GetValue(objectValue), newValue = field.DeSerializeMethod(deSerializer, fieldValue);
if (!object.ReferenceEquals(newValue, fieldValue))
{
field.Field.SetValue(objectValue, newValue);
}
}
}
value = (valueType)objectValue;
}
/// <summary>
/// 添加字段
/// </summary>
/// <param name="field">字段信息</param>
public void Push(FieldSize field)
{
Type fieldType = field.Field.FieldType;
generator.Emit(OpCodes.Ldarg_0);
if (field.Field.IsStatic)
{
LocalBuilder staticMember = generator.DeclareLocal(fieldType);
generator.initobj(fieldType, staticMember);
generator.Emit(OpCodes.Ldloca, staticMember);
}
else
{
generator.Emit(OpCodes.Ldarg_1);
if (!isValueType)
{
generator.Emit(OpCodes.Ldind_Ref);
}
generator.Emit(OpCodes.Ldflda, field.Field);
}
generator.call(DeSerializer.GetMemberDeSerializeMethod(fieldType) ?? DeSerializeMethodCache.GetMember(fieldType));
}
static TypeDeSerializer()
{
Type type = typeof(valueType), attributeType;
MethodInfo methodInfo = DeSerializer.GetDeSerializeMethod(type);
attribute = type.customAttribute <SerializeAttribute>(out attributeType) ?? Serializer.DefaultAttribute;
if (methodInfo != null)
{
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), methodInfo);
IsReferenceMember = false;
isValueType = true;
return;
}
if (type.IsArray)
{
isValueType = true;
if (type.GetArrayRank() == 1)
{
Type elementType = type.GetElementType();
if (!elementType.IsPointer && !typeof(Delegate).IsAssignableFrom(elementType))
{
if (elementType.IsValueType)
{
if (elementType.IsEnum)
{
Type enumType = System.Enum.GetUnderlyingType(elementType);
if (enumType == typeof(uint))
{
methodInfo = DeSerializeMethodCache.EnumUIntArrayMethod.MakeGenericMethod(elementType);
}
else if (enumType == typeof(byte))
{
methodInfo = DeSerializeMethodCache.EnumByteArrayMethod.MakeGenericMethod(elementType);
}
else if (enumType == typeof(ulong))
{
methodInfo = DeSerializeMethodCache.EnumULongArrayMethod.MakeGenericMethod(elementType);
}
else if (enumType == typeof(ushort))
{
methodInfo = DeSerializeMethodCache.EnumUShortArrayMethod.MakeGenericMethod(elementType);
}
else if (enumType == typeof(long))
{
methodInfo = DeSerializeMethodCache.EnumLongArrayMethod.MakeGenericMethod(elementType);
}
else if (enumType == typeof(short))
{
methodInfo = DeSerializeMethodCache.EnumShortArrayMethod.MakeGenericMethod(elementType);
}
else if (enumType == typeof(sbyte))
{
methodInfo = DeSerializeMethodCache.EnumSByteArrayMethod.MakeGenericMethod(elementType);
}
else
{
methodInfo = DeSerializeMethodCache.EnumIntArrayMethod.MakeGenericMethod(elementType);
}
IsReferenceMember = false;
}
else if (elementType.IsGenericType && elementType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
methodInfo = DeSerializeMethodCache.NullableArrayMethod.MakeGenericMethod(elementType = elementType.GetGenericArguments()[0]);
IsReferenceMember = SerializeMethodCache.IsReferenceMember(elementType);
}
else
{
methodInfo = DeSerializeMethodCache.StructArrayMethod.MakeGenericMethod(elementType);
IsReferenceMember = SerializeMethodCache.IsReferenceMember(elementType);
}
}
else
{
methodInfo = DeSerializeMethodCache.ArrayMethod.MakeGenericMethod(elementType);
IsReferenceMember = SerializeMethodCache.IsReferenceMember(elementType);
}
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), methodInfo);
return;
}
}
DefaultDeSerializer = fromNull;
IsReferenceMember = false;
return;
}
if (type.IsEnum)
{
Type enumType = System.Enum.GetUnderlyingType(type);
if (enumType == typeof(uint))
{
DefaultDeSerializer = enumUInt;
}
else if (enumType == typeof(byte))
{
DefaultDeSerializer = enumByte;
}
else if (enumType == typeof(ulong))
{
DefaultDeSerializer = enumULong;
}
else if (enumType == typeof(ushort))
{
DefaultDeSerializer = enumUShort;
}
else if (enumType == typeof(long))
{
DefaultDeSerializer = enumLong;
}
else if (enumType == typeof(short))
{
DefaultDeSerializer = enumShort;
}
else if (enumType == typeof(sbyte))
{
DefaultDeSerializer = enumSByte;
}
else
{
DefaultDeSerializer = enumInt;
}
IsReferenceMember = false;
isValueType = true;
return;
}
if (type.IsPointer || typeof(Delegate).IsAssignableFrom(type))
{
DefaultDeSerializer = fromNull;
IsReferenceMember = false;
isValueType = true;
return;
}
if (type.IsGenericType)
{
Type genericType = type.GetGenericTypeDefinition();
Type[] parameterTypes = type.GetGenericArguments();
if (genericType == typeof(LeftArray <>))
{
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.LeftArrayDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
IsReferenceMember = SerializeMethodCache.IsReferenceMember(parameterTypes[0]);
isValueType = true;
return;
}
#if !Serialize
if (genericType == typeof(SubArray <>))
{
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.SubArrayDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
IsReferenceMember = SerializeMethodCache.IsReferenceMember(parameterTypes[0]);
isValueType = true;
return;
}
#endif
if (genericType == typeof(Dictionary <,>))
{
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.DictionaryDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
IsReferenceMember = SerializeMethodCache.IsReferenceMember(parameterTypes[0]) || SerializeMethodCache.IsReferenceMember(parameterTypes[1]);
isValueType = true;
return;
}
if (genericType == typeof(Nullable <>))
{
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.NullableDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
IsReferenceMember = SerializeMethodCache.IsReferenceMember(parameterTypes[0]);
isValueType = true;
return;
}
if (genericType == typeof(KeyValuePair <,>))
{
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.KeyValuePairDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
IsReferenceMember = SerializeMethodCache.IsReferenceMember(parameterTypes[0]) || SerializeMethodCache.IsReferenceMember(parameterTypes[1]);
isValueType = true;
return;
}
if (genericType == typeof(SortedDictionary <,>))
{
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.SortedDictionaryDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
IsReferenceMember = SerializeMethodCache.IsReferenceMember(parameterTypes[0]) || SerializeMethodCache.IsReferenceMember(parameterTypes[1]);
isValueType = true;
return;
}
if (genericType == typeof(SortedList <,>))
{
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.SortedListDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
IsReferenceMember = SerializeMethodCache.IsReferenceMember(parameterTypes[0]) || SerializeMethodCache.IsReferenceMember(parameterTypes[1]);
isValueType = true;
return;
}
}
if ((methodInfo = SerializeMethodCache.GetCustom(type, false)) != null)
{
if (type.IsValueType)
{
#if NOJIT
DefaultDeSerializer = new CustomDeSerializer(methodInfo).DeSerialize;
#else
DynamicMethod dynamicMethod = new DynamicMethod("CustomDeSerializer", null, new Type[] { typeof(DeSerializer), type.MakeByRefType() }, type, true);
ILGenerator generator = dynamicMethod.GetILGenerator();
generator.Emit(OpCodes.Ldarg_1);
generator.Emit(OpCodes.Ldarg_0);
generator.call(methodInfo);
generator.Emit(OpCodes.Ret);
DefaultDeSerializer = (deSerialize)dynamicMethod.CreateDelegate(typeof(deSerialize));
#endif
}
else
{
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), methodInfo);
}
IsReferenceMember = attribute.IsReferenceMember;
isValueType = true;
return;
}
if (type.IsAbstract || type.IsInterface || Emit.Constructor <valueType> .New == null)
{
DefaultDeSerializer = noConstructor;
isValueType = IsReferenceMember = true;
return;
}
IsReferenceMember = attribute.IsReferenceMember;
foreach (Type interfaceType in type.GetInterfaces())
{
if (interfaceType.IsGenericType)
{
Type genericType = interfaceType.GetGenericTypeDefinition();
if (genericType == typeof(ICollection <>))
{
Type[] parameters = interfaceType.GetGenericArguments();
Type argumentType = parameters[0];
parameters[0] = argumentType.MakeArrayType();
ConstructorInfo constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, parameters, null);
if (constructorInfo != null)
{
methodInfo = (type.IsValueType ? DeSerializeMethodCache.StructCollectionMethod : DeSerializeMethodCache.ClassCollectionMethod).MakeGenericMethod(type, argumentType);
break;
}
parameters[0] = typeof(IList <>).MakeGenericType(argumentType);
constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, parameters, null);
if (constructorInfo != null)
{
methodInfo = (type.IsValueType ? DeSerializeMethodCache.StructCollectionMethod : DeSerializeMethodCache.ClassCollectionMethod).MakeGenericMethod(type, argumentType);
break;
}
parameters[0] = typeof(ICollection <>).MakeGenericType(argumentType);
constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, parameters, null);
if (constructorInfo != null)
{
methodInfo = (type.IsValueType ? DeSerializeMethodCache.StructCollectionMethod : DeSerializeMethodCache.ClassCollectionMethod).MakeGenericMethod(type, argumentType);
break;
}
parameters[0] = typeof(IEnumerable <>).MakeGenericType(argumentType);
constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, parameters, null);
if (constructorInfo != null)
{
methodInfo = (type.IsValueType ? DeSerializeMethodCache.StructCollectionMethod : DeSerializeMethodCache.ClassCollectionMethod).MakeGenericMethod(type, argumentType);
break;
}
}
else if (genericType == typeof(IDictionary <,>))
{
ConstructorInfo constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { interfaceType }, null);
if (constructorInfo != null)
{
Type[] parameters = interfaceType.GetGenericArguments();
methodInfo = (type.IsValueType ? DeSerializeMethodCache.StructDictionaryDeSerializeMethod : DeSerializeMethodCache.ClassDictionaryDeSerializeMethod).MakeGenericMethod(type, parameters[0], parameters[1]);
break;
}
}
}
}
if (methodInfo != null)
{
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), methodInfo);
return;
}
if (type.IsValueType)
{
isValueType = true;
}
else if (attribute != Serializer.DefaultAttribute && attributeType != type)
{
for (Type baseType = type.BaseType; baseType != typeof(object); baseType = baseType.BaseType)
{
SerializeAttribute baseAttribute = baseType.customAttribute <SerializeAttribute>();
if (baseAttribute != null)
{
if (baseAttribute.IsBaseType)
{
methodInfo = DeSerializeMethodCache.BaseSerializeMethod.MakeGenericMethod(baseType, type);
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), methodInfo);
return;
}
break;
}
}
}
LeftArray <DeSerializeVersionField> attributeFields = new LeftArray <DeSerializeVersionField>();
if ((attribute.MemberFilters & MemberFilters.PublicInstanceField) != 0)
{
appendField(ref attributeFields, MemberIndexGroup <valueType> .Group.PublicFields);
}
else
{
foreach (FieldIndex field in MemberIndexGroup <valueType> .Group.PublicFields)
{
attributeFields.Add(new DeSerializeVersionField {
Field = field
});
}
}
if ((attribute.MemberFilters & MemberFilters.NonPublicInstanceField) != 0)
{
appendField(ref attributeFields, MemberIndexGroup <valueType> .Group.NonPublicFields);
}
if (attribute.IsAnonymousFields)
{
appendField(ref attributeFields, MemberIndexGroup <valueType> .Group.AnonymousFields);
}
foreach (FieldIndex field in new MemberIndexGroup(type, true).NonPublicFields)
{
Type fieldType = field.Member.FieldType;
if (!fieldType.IsPointer && (!fieldType.IsArray || fieldType.GetArrayRank() == 1) && !field.IsIgnore && !typeof(Delegate).IsAssignableFrom(fieldType))
{
SerializeMemberAttribute memberAttribute = field.GetAttribute <SerializeMemberAttribute>(true);
if (memberAttribute != null && memberAttribute.IsSetup && memberAttribute.RemoveGlobalVersion != memberAttribute.GlobalVersion)
{
attributeFields.Add(new DeSerializeVersionField {
Field = field, Attribute = memberAttribute
});
if (memberAttribute.IsRemove)
{
attributeFields.Add(new DeSerializeVersionField {
Field = field, Attribute = memberAttribute, IsRemove = true
});
}
}
}
}
isMemberMap = attribute.GetIsMemberMap;
isJson = attribute.GetIsJson;
uint globalVersion = 0, removeMemberCount = 0;
int noSerializeMemberCount = 0;
LeftArray <DeSerializeVersionFields <valueType> > deSerializeVersionFields = default(LeftArray <DeSerializeVersionFields <valueType> >);
LeftArray <DeSerializeVersionField> attributeVersionFields = new LeftArray <DeSerializeVersionField>(attributeFields.Length);
foreach (DeSerializeVersionField field in attributeFields.Sort(DeSerializeVersionField.GlobalVersionSort))
{
if (field.GlobalVersion != globalVersion)
{
deSerializeVersionFields.Add(new DeSerializeVersionFields <valueType>(globalVersion, attributeVersionFields.GetArray(), removeMemberCount, noSerializeMemberCount));
globalVersion = field.GlobalVersion;
}
if (field.IsRemove)
{
attributeVersionFields.RemoveToEnd(value => object.ReferenceEquals(value.Field, field.Field));
if (field.Attribute.IsRemove)
{
--removeMemberCount;
}
}
else
{
attributeVersionFields.Add(field);
if (field.Attribute != null)
{
if (field.Attribute.IsRemove)
{
++removeMemberCount;
}
}
else
{
++noSerializeMemberCount;
}
}
}
fieldDeSerializer = new DeSerializeVersionFields <valueType>(globalVersion, attributeVersionFields.GetArray(), removeMemberCount, noSerializeMemberCount).CreateOnly(attribute);
if (deSerializeVersionFields.Length != 0)
{
int count = deSerializeVersionFields.Length;
DeSerializeVersionFields <valueType>[] deSerializeVersionFieldsArray = new DeSerializeVersionFields <valueType> [count];
foreach (DeSerializeVersionFields <valueType> value in deSerializeVersionFields)
{
deSerializeVersionFieldsArray[--count] = value;
deSerializeVersionFieldsArray[count].CreateLock = new object();
}
fieldDeSerializers = deSerializeVersionFieldsArray;
}
}
private unsafe static void enumULong(DeSerializer deSerializer, ref valueType value)
{
deSerializer.EnumULong(ref value);
}
private static void fromNull(DeSerializer deSerializer, ref valueType value)
{
deSerializer.CheckNull();
value = default(valueType);
}
/// <summary>
/// 设置字段信息
/// </summary>
/// <param name="field"></param>
internal void Set(FieldSize field)
{
Field = field.Field;
MemberIndex = field.MemberIndex;
DeSerializeMethod = (Func <DeSerializer, object, object>) typeof(AutoCSer.Reflection.InvokeMethodRef2 <,>).MakeGenericType(typeof(DeSerializer), Field.FieldType).GetMethod("getTypeObjectReturn", BindingFlags.Static | BindingFlags.NonPublic).Invoke(null, new object[] { DeSerializer.GetMemberDeSerializeMethod(Field.FieldType) ?? DeSerializeMethodCache.GetMember(Field.FieldType) });
}
/// <summary>
/// 反序列化
/// </summary>
/// <param name="deSerializer"></param>
/// <param name="value"></param>
public void DeSerialize(DeSerializer deSerializer, ref valueType value)
{
method(ref value, deSerializer);
}
