/// <summary>
/// 创建二进制数据反序列化
/// </summary>
/// <param name="attribute"></param>
/// <returns></returns>
internal TypeDeSerializer <valueType> CreateOnly(SerializeAttribute attribute)
{
DeSerializeVersionField[] fieldArray = this.fields;
LeftArray <FieldSize> fixedFields = new LeftArray <FieldSize>(fieldArray.Length - noSerializeMemberCount), fields = new LeftArray <FieldSize>(fieldArray.Length - noSerializeMemberCount);
LeftArray <AutoCSer.Metadata.FieldIndex> jsonFields = new LeftArray <AutoCSer.Metadata.FieldIndex>();
int fixedSize = 0;
AutoCSer.Algorithm.QuickSort.Sort(fieldArray, DeSerializeVersionField.MemberNameSort, 0, fieldArray.Length);
if (attribute.GetIsMemberMap)
{
int memberIndex = 0;
LeftArray <DeSerializeVersionField> newFields = new LeftArray <DeSerializeVersionField>(fieldArray.Length);
foreach (DeSerializeVersionField field in fieldArray)
{
if (field.Attribute != null)
{
if (field.Field.MemberIndex == memberIndex)
{
newFields.Add(field);
}
else
{
newFields.Add(field.Copy(memberIndex));
}
}
++memberIndex;
}
fieldArray = newFields.ToArray();
}
else if (noSerializeMemberCount != 0)
{
fieldArray = fieldArray.getFindArray(value => value.Attribute != null);
}
foreach (DeSerializeVersionField field in fieldArray)
{
SerializeMemberAttribute memberAttribute = field.Attribute;
if (memberAttribute.GetIsJson)
{
jsonFields.Add(field.Field);
}
else
{
FieldSize value = new FieldSize(field.Field);
if (value.FixedSize == 0)
{
fields.Add(value);
}
else
{
fixedFields.Add(value);
fixedSize += value.FixedSize;
}
}
}
int memberCountVerify;
Fields <FieldSize> fieldSizes = new Fields <FieldSize>(ref fixedFields, ref fields, ref jsonFields, fixedSize, attribute.GetIsJson, out memberCountVerify);
return(DeSerializer = new TypeDeSerializer <valueType>(GlobalVersion, ref fieldSizes, memberCountVerify));
}
/// <summary>
/// 追加字段信息
/// </summary>
/// <param name="attributeFields"></param>
/// <param name="fieldIndexs"></param>
private static void appendField(ref LeftArray <DeSerializeVersionField> attributeFields, FieldIndex[] fieldIndexs)
{
foreach (FieldIndex field in fieldIndexs)
{
bool isSerialize = false;
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)
{
attributeFields.Add(new DeSerializeVersionField {
Field = field, Attribute = SerializeMemberAttribute.Null
});
isSerialize = true;
}
else if (memberAttribute.IsSetup)
{
attributeFields.Add(new DeSerializeVersionField {
Field = field, Attribute = memberAttribute
});
if (memberAttribute.IsRemove)
{
attributeFields.Add(new DeSerializeVersionField {
Field = field, Attribute = memberAttribute, IsRemove = true
});
}
isSerialize = true;
}
}
if (!isSerialize)
{
attributeFields.Add(new DeSerializeVersionField {
Field = field
});
}
}
}
/// <summary>
/// 获取字段成员集合
/// </summary>
/// <param name="fieldIndexs"></param>
/// <param name="isJson"></param>
/// <param name="memberCountVerify"></param>
/// <returns>字段成员集合</returns>
public static Fields <FieldSize> GetFields(FieldIndex[] fieldIndexs, bool isJson, out int memberCountVerify)
{
LeftArray <FieldSize> fixedFields = new LeftArray <FieldSize>(fieldIndexs.Length), fields = new LeftArray <FieldSize>(fieldIndexs.Length);
LeftArray <FieldIndex> jsonFields = new LeftArray <FieldIndex>();
int fixedSize = 0;
foreach (FieldIndex field in fieldIndexs)
{
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.IsRemove))
{
if (memberAttribute != null && memberAttribute.GetIsJson)
{
jsonFields.Add(field);
}
else
{
FieldSize value = new FieldSize(field);
if (value.FixedSize == 0)
{
fields.Add(value);
}
else
{
fixedFields.Add(value);
fixedSize += value.FixedSize;
}
}
}
}
}
return(new Fields <FieldSize>(ref fixedFields, ref fields, ref jsonFields, fixedSize, isJson, out memberCountVerify));
}
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;
}
}