static TypeSerializer()
{
Type type = typeof(valueType), attributeType;
MethodInfo methodInfo = Serializer.GetSerializeMethod(type);
attribute = type.customAttribute <SerializeAttribute>(out attributeType) ?? Serializer.DefaultAttribute;
if (methodInfo != null)
{
DefaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), methodInfo);
isValueType = true;
IsReferenceMember = false;
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 = GenericType.Get(elementType).BinarySerializeEnumUIntArrayMethod; // SerializeMethodCache.EnumUIntArrayMethod;
}
else if (enumType == typeof(byte))
{
methodInfo = GenericType.Get(elementType).BinarySerializeEnumByteArrayMethod; //SerializeMethodCache.EnumByteArrayMethod;
}
else if (enumType == typeof(ulong))
{
methodInfo = GenericType.Get(elementType).BinarySerializeEnumULongArrayMethod; //SerializeMethodCache.EnumULongArrayMethod;
}
else if (enumType == typeof(ushort))
{
methodInfo = GenericType.Get(elementType).BinarySerializeEnumUShortArrayMethod; //SerializeMethodCache.EnumUShortArrayMethod;
}
else if (enumType == typeof(long))
{
methodInfo = GenericType.Get(elementType).BinarySerializeEnumLongArrayMethod; //SerializeMethodCache.EnumLongArrayMethod;
}
else if (enumType == typeof(short))
{
methodInfo = GenericType.Get(elementType).BinarySerializeEnumShortArrayMethod; //SerializeMethodCache.EnumShortArrayMethod;
}
else if (enumType == typeof(sbyte))
{
methodInfo = GenericType.Get(elementType).BinarySerializeEnumSByteArrayMethod; //SerializeMethodCache.EnumSByteArrayMethod;
}
else
{
methodInfo = GenericType.Get(elementType).BinarySerializeEnumIntArrayMethod; //SerializeMethodCache.EnumIntArrayMethod;
}
//methodInfo = methodInfo.MakeGenericMethod(elementType);
IsReferenceMember = false;
}
else if (elementType.IsGenericType && elementType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
//methodInfo = SerializeMethodCache.NullableArrayMethod.MakeGenericMethod(elementType = elementType.GetGenericArguments()[0]);
methodInfo = StructGenericType.Get(elementType = elementType.GetGenericArguments()[0]).BinarySerializeNullableArrayMethod;
IsReferenceMember = SerializeMethodCache.IsReferenceMember(elementType);
}
else
{
//methodInfo = SerializeMethodCache.StructArrayMethod.MakeGenericMethod(elementType);
methodInfo = GenericType.Get(elementType).BinarySerializeStructArrayMethod;
IsReferenceMember = SerializeMethodCache.IsReferenceMember(elementType);
}
}
else
{
//methodInfo = SerializeMethodCache.ArrayMethod.MakeGenericMethod(elementType);
methodInfo = ClassGenericType.Get(elementType).BinarySerializeArrayMethod;
IsReferenceMember = SerializeMethodCache.IsReferenceMember(elementType);
}
DefaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), methodInfo);
return;
}
}
DefaultSerializer = toNull;
IsReferenceMember = false;
return;
}
if (type.IsEnum)
{
Type enumType = System.Enum.GetUnderlyingType(type);
if (enumType == typeof(uint))
{
DefaultSerializer = enumUInt;
}
else if (enumType == typeof(byte))
{
DefaultSerializer = enumByte;
}
else if (enumType == typeof(ulong))
{
DefaultSerializer = enumULong;
}
else if (enumType == typeof(ushort))
{
DefaultSerializer = enumUShort;
}
else if (enumType == typeof(long))
{
DefaultSerializer = enumLong;
}
else if (enumType == typeof(short))
{
DefaultSerializer = enumShort;
}
else if (enumType == typeof(sbyte))
{
DefaultSerializer = enumSByte;
}
else
{
DefaultSerializer = enumInt;
}
isValueType = true;
IsReferenceMember = false;
return;
}
if (type.IsPointer || typeof(Delegate).IsAssignableFrom(type))
{
DefaultSerializer = toNull;
IsReferenceMember = false;
isValueType = true;
return;
}
if (type.IsGenericType)
{
Type genericType = type.GetGenericTypeDefinition();
Type[] parameterTypes = type.GetGenericArguments();
if (genericType == typeof(LeftArray <>))
{
//DefaultSerializer = (Action<Serializer, valueType>)Delegate.CreateDelegate(typeof(Action<Serializer, valueType>), SerializeMethodCache.LeftArraySerializeMethod.MakeGenericMethod(parameterTypes));
DefaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), GenericType.Get(parameterTypes[0]).BinarySerializeLeftArrayMethod);
IsReferenceMember = SerializeMethodCache.IsReferenceMember(parameterTypes[0]);
isValueType = true;
return;
}
#if !Serialize
if (genericType == typeof(SubArray <>))
{
//DefaultSerializer = (Action<Serializer, valueType>)Delegate.CreateDelegate(typeof(Action<Serializer, valueType>), SerializeMethodCache.SubArraySerializeMethod.MakeGenericMethod(parameterTypes));
DefaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), GenericType.Get(parameterTypes[0]).BinarySerializeSubArrayMethod);
IsReferenceMember = SerializeMethodCache.IsReferenceMember(parameterTypes[0]);
isValueType = true;
return;
}
#endif
if (genericType == typeof(Dictionary <,>) || genericType == typeof(SortedDictionary <,>) || genericType == typeof(SortedList <,>))
{
//DefaultSerializer = (Action<Serializer, valueType>)Delegate.CreateDelegate(typeof(Action<Serializer, valueType>), SerializeMethodCache.DictionarySerializeMethod.MakeGenericMethod(type, parameterTypes[0], parameterTypes[1]));
DefaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), DictionaryGenericType3.Get(type, parameterTypes[0], parameterTypes[1]).BinarySerializeDictionaryMethod);
IsReferenceMember = SerializeMethodCache.IsReferenceMember(parameterTypes[0]) || SerializeMethodCache.IsReferenceMember(parameterTypes[1]);
isValueType = true;
return;
}
if (genericType == typeof(Nullable <>))
{
//DefaultSerializer = (Action<Serializer, valueType>)Delegate.CreateDelegate(typeof(Action<Serializer, valueType>), SerializeMethodCache.NullableSerializeMethod.MakeGenericMethod(parameterTypes));
DefaultSerializer = (Action <Serializer, valueType>)StructGenericType.Get(parameterTypes[0]).BinarySerializeNullableDelegate;
IsReferenceMember = SerializeMethodCache.IsReferenceMember(parameterTypes[0]);
isValueType = true;
return;
}
if (genericType == typeof(KeyValuePair <,>))
{
//DefaultSerializer = (Action<Serializer, valueType>)Delegate.CreateDelegate(typeof(Action<Serializer, valueType>), SerializeMethodCache.KeyValuePairSerializeMethod.MakeGenericMethod(parameterTypes));
DefaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), GenericType2.Get(parameterTypes).BinarySerializeKeyValuePairMethod);
IsReferenceMember = SerializeMethodCache.IsReferenceMember(parameterTypes[0]) || SerializeMethodCache.IsReferenceMember(parameterTypes[1]);
isValueType = true;
return;
}
}
if ((methodInfo = SerializeMethodCache.GetCustom(type, true)) != null)
{
if (type.IsValueType)
{
#if NOJIT
DefaultSerializer = new CustomSerializer(methodInfo).Serialize;
#else
DynamicMethod dynamicMethod = new DynamicMethod("CustomSerializer", null, new Type[] { typeof(Serializer), type }, type, true);
ILGenerator generator = dynamicMethod.GetILGenerator();
generator.Emit(OpCodes.Ldarga_S, 1);
generator.Emit(OpCodes.Ldarg_0);
generator.call(methodInfo);
generator.Emit(OpCodes.Ret);
DefaultSerializer = (Action <Serializer, valueType>)dynamicMethod.CreateDelegate(typeof(Action <Serializer, valueType>));
#endif
}
else
{
DefaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), methodInfo);
}
IsReferenceMember = attribute.IsReferenceMember;
isValueType = true;
return;
}
if (type.IsInterface || type.IsAbstract || Emit.Constructor <valueType> .New == null)
{
DefaultSerializer = noConstructor;
isValueType = IsReferenceMember = true;
return;
}
ConstructorInfo constructorInfo = null;
Type argumentType = null;
IsReferenceMember = attribute.IsReferenceMember;
foreach (Type interfaceType in type.GetInterfaces())
{
if (interfaceType.IsGenericType)
{
Type genericType = interfaceType.GetGenericTypeDefinition();
if (genericType == typeof(ICollection <>))
{
Type[] parameterTypes = interfaceType.GetGenericArguments();
argumentType = parameterTypes[0];
parameterTypes[0] = argumentType.MakeArrayType();
constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, parameterTypes, null);
if (constructorInfo != null)
{
break;
}
parameterTypes[0] = typeof(IList <>).MakeGenericType(argumentType);
constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, parameterTypes, null);
if (constructorInfo != null)
{
break;
}
parameterTypes[0] = typeof(ICollection <>).MakeGenericType(argumentType);
constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, parameterTypes, null);
if (constructorInfo != null)
{
break;
}
parameterTypes[0] = typeof(IEnumerable <>).MakeGenericType(argumentType);
constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, parameterTypes, null);
if (constructorInfo != null)
{
break;
}
}
else if (genericType == typeof(IDictionary <,>))
{
constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { interfaceType }, null);
if (constructorInfo != null)
{
Type[] parameters = interfaceType.GetGenericArguments();
//methodInfo = (type.IsValueType ? SerializeMethodCache.StructDictionaryMethod : SerializeMethodCache.ClassDictionaryMethod).MakeGenericMethod(type, parameters[0], parameters[1]);
if (type.IsValueType)
{
methodInfo = DictionaryGenericType3.Get(type, parameters[0], parameters[1]).BinarySerializeStructDictionaryMethod;
}
else
{
methodInfo = DictionaryGenericType3.Get(type, parameters[0], parameters[1]).BinarySerializeClassDictionaryMethod;
}
DefaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), methodInfo);
return;
}
}
}
}
if (constructorInfo != null)
{
if (argumentType.IsValueType && argumentType.IsEnum)
{
Type enumType = System.Enum.GetUnderlyingType(argumentType);
//if (enumType == typeof(uint)) methodInfo = type.IsValueType ? SerializeMethodCache.StructEnumUIntCollectionMethod : SerializeMethodCache.ClassEnumUIntCollectionMethod;
//else if (enumType == typeof(byte)) methodInfo = type.IsValueType ? SerializeMethodCache.StructEnumByteCollectionMethod : SerializeMethodCache.ClassEnumByteCollectionMethod;
//else if (enumType == typeof(ulong)) methodInfo = type.IsValueType ? SerializeMethodCache.StructEnumULongCollectionMethod : SerializeMethodCache.ClassEnumULongCollectionMethod;
//else if (enumType == typeof(ushort)) methodInfo = type.IsValueType ? SerializeMethodCache.StructEnumUShortCollectionMethod : SerializeMethodCache.ClassEnumUShortCollectionMethod;
//else if (enumType == typeof(long)) methodInfo = type.IsValueType ? SerializeMethodCache.StructEnumLongCollectionMethod : SerializeMethodCache.ClassEnumLongCollectionMethod;
//else if (enumType == typeof(short)) methodInfo = type.IsValueType ? SerializeMethodCache.StructEnumShortCollectionMethod : SerializeMethodCache.ClassEnumShortCollectionMethod;
//else if (enumType == typeof(sbyte)) methodInfo = type.IsValueType ? SerializeMethodCache.StructEnumSByteCollectionMethod : SerializeMethodCache.ClassEnumSByteCollectionMethod;
//else methodInfo = type.IsValueType ? SerializeMethodCache.StructEnumIntCollectionMethod : SerializeMethodCache.ClassEnumIntCollectionMethod;
//methodInfo = methodInfo.MakeGenericMethod(argumentType, type);
if (enumType == typeof(uint))
{
methodInfo = type.IsValueType ? CollectionGenericType2.Get(type, argumentType).BinarySerializeStructEnumUIntCollectionMethod : CollectionGenericType2.Get(type, argumentType).BinarySerializeClassEnumUIntCollectionMethod;
}
else if (enumType == typeof(byte))
{
methodInfo = type.IsValueType ? CollectionGenericType2.Get(type, argumentType).BinarySerializeStructEnumByteCollectionMethod : CollectionGenericType2.Get(type, argumentType).BinarySerializeClassEnumByteCollectionMethod;
}
else if (enumType == typeof(ulong))
{
methodInfo = type.IsValueType ? CollectionGenericType2.Get(type, argumentType).BinarySerializeStructEnumULongCollectionMethod : CollectionGenericType2.Get(type, argumentType).BinarySerializeClassEnumULongCollectionMethod;
}
else if (enumType == typeof(ushort))
{
methodInfo = type.IsValueType ? CollectionGenericType2.Get(type, argumentType).BinarySerializeStructEnumUShortCollectionMethod : CollectionGenericType2.Get(type, argumentType).BinarySerializeClassEnumUShortCollectionMethod;
}
else if (enumType == typeof(long))
{
methodInfo = type.IsValueType ? CollectionGenericType2.Get(type, argumentType).BinarySerializeStructEnumLongCollectionMethod : CollectionGenericType2.Get(type, argumentType).BinarySerializeClassEnumLongCollectionMethod;
}
else if (enumType == typeof(short))
{
methodInfo = type.IsValueType ? CollectionGenericType2.Get(type, argumentType).BinarySerializeStructEnumShortCollectionMethod : CollectionGenericType2.Get(type, argumentType).BinarySerializeClassEnumShortCollectionMethod;
}
else if (enumType == typeof(sbyte))
{
methodInfo = type.IsValueType ? CollectionGenericType2.Get(type, argumentType).BinarySerializeStructEnumSByteCollectionMethod : CollectionGenericType2.Get(type, argumentType).BinarySerializeClassEnumSByteCollectionMethod;
}
else
{
methodInfo = type.IsValueType ? CollectionGenericType2.Get(type, argumentType).BinarySerializeStructEnumIntCollectionMethod : CollectionGenericType2.Get(type, argumentType).BinarySerializeClassEnumIntCollectionMethod;
}
}
//else methodInfo = (type.IsValueType ? SerializeMethodCache.StructCollectionMethod : SerializeMethodCache.ClassCollectionMethod).MakeGenericMethod(argumentType, type);
else
{
if (type.IsValueType)
{
methodInfo = CollectionGenericType2.Get(type, argumentType).BinarySerializeStructCollectionMethod;
}
else
{
methodInfo = CollectionGenericType2.Get(type, argumentType).BinarySerializeClassCollectionMethod;
}
}
DefaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), 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 = SerializeMethodCache.BaseSerializeMethod.MakeGenericMethod(baseType, type);
DefaultSerializer = (Action <Serializer, valueType>)Delegate.CreateDelegate(typeof(Action <Serializer, valueType>), methodInfo);
return;
}
break;
}
}
}
isJson = attribute.GetIsJson;
isMemberMap = attribute.GetIsMemberMap;
Fields <FieldSize> fields = SerializeMethodCache.GetFields(attribute.IsAnonymousFields ? MemberIndexGroup <valueType> .GetAnonymousFields(attribute.MemberFilters) : MemberIndexGroup <valueType> .GetFields(attribute.MemberFilters), isJson, out memberCountVerify);
//if (!type.IsValueType && (fields.FixedFields.length | fields.Fields.length | fields.JsonFields.length) == 0)
//{
// DefaultSerializer = noMember;
// isValueType = true;
// IsReferenceMember = false;
// return;
//}
fixedFillSize = -fields.FixedSize & 3;
fixedSize = (fields.FixedSize + (sizeof(int) + 3)) & (int.MaxValue - 3);
#if NOJIT
fixedMemberSerializer = new FieldFerializer(ref fields.FixedFields).Serialize;
if (isMemberMap)
{
fixedMemberMapSerializer = new MemberMapSerializer(ref fields.FixedFields).Serialize;
}
if (fields.FieldArray.Length != 0)
{
memberSerializer = new FieldFerializer(ref fields.FieldArray).Serialize;
if (isMemberMap)
{
memberMapSerializer = new MemberMapSerializer(ref fields.FieldArray).Serialize;
}
}
#else
SerializeMemberDynamicMethod fixedDynamicMethod = new SerializeMemberDynamicMethod(type);
SerializeMemberMapDynamicMethod fixedMemberMapDynamicMethod = isMemberMap ? new SerializeMemberMapDynamicMethod(type) : default(SerializeMemberMapDynamicMethod);
foreach (FieldSize member in fields.FixedFields)
{
fixedDynamicMethod.Push(member);
if (isMemberMap)
{
fixedMemberMapDynamicMethod.Push(member);
}
}
fixedMemberSerializer = (Action <Serializer, valueType>)fixedDynamicMethod.Create <Action <Serializer, valueType> >();
if (isMemberMap)
{
fixedMemberMapSerializer = (Action <MemberMap, Serializer, valueType>)fixedMemberMapDynamicMethod.Create <Action <MemberMap, Serializer, valueType> >();
}
if (fields.FieldArray.Length != 0)
{
SerializeMemberDynamicMethod dynamicMethod = new SerializeMemberDynamicMethod(type);
SerializeMemberMapDynamicMethod memberMapDynamicMethod = isMemberMap ? new SerializeMemberMapDynamicMethod(type) : default(SerializeMemberMapDynamicMethod);
foreach (FieldSize member in fields.FieldArray)
{
dynamicMethod.Push(member);
if (isMemberMap)
{
memberMapDynamicMethod.Push(member);
}
}
memberSerializer = (Action <Serializer, valueType>)dynamicMethod.Create <Action <Serializer, valueType> >();
if (isMemberMap)
{
memberMapSerializer = (Action <MemberMap, Serializer, valueType>)memberMapDynamicMethod.Create <Action <MemberMap, Serializer, valueType> >();
}
}
#endif
if (fields.JsonFields.Length != 0)
{
jsonMemberMap = new MemberMap <valueType>();
jsonMemberIndexs = new int[fields.JsonFields.Length];
int index = 0;
foreach (FieldIndex field in fields.JsonFields)
{
jsonMemberMap.SetMember(jsonMemberIndexs[index++] = field.MemberIndex);
}
}
}
/// <summary>
/// 未知类型枚举反序列化委托调用函数信息
/// </summary>
/// <param name="type">数组类型</param>
/// <returns>未知类型反序列化委托调用函数信息</returns>
public static MethodInfo GetMember(Type type)
{
MethodInfo method;
if (memberMethods.TryGetValue(type, out method))
{
return(method);
}
if (type.IsArray)
{
Type elementType = type.GetElementType();
if (elementType.IsValueType)
{
if (elementType.IsEnum)
{
method = EnumGenericType.Get(elementType).BinaryDeSerializeEnumArrayMemberDelegate.Method;
}
else if (elementType.IsGenericType && elementType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
method = StructGenericType.Get(elementType.GetGenericArguments()[0]).BinaryDeSerializeNullableArrayMemberMethod;
}
else
{
method = GenericType.Get(elementType).BinaryDeSerializeStructArrayMemberMethod;
}
}
else
{
method = ClassGenericType.Get(elementType).BinaryDeSerializeArrayMemberMethod;
}
}
else if (type.IsEnum)
{
method = EnumGenericType.Get(type).BinaryDeSerializeEnumMemberDelegate.Method;
}
else
{
if (type.IsGenericType)
{
Type genericType = type.GetGenericTypeDefinition();
if (genericType == typeof(Dictionary <,>))
{
method = GenericType2.Get(type.GetGenericArguments()).BinaryDeSerializeDictionaryMemberMethod;
}
else if (genericType == typeof(Nullable <>))
{
method = StructGenericType.Get(type.GetGenericArguments()[0]).BinaryDeSerializeNullableMemberMethod;
}
else if (genericType == typeof(KeyValuePair <,>))
{
method = GenericType2.Get(type.GetGenericArguments()).BinaryDeSerializeKeyValuePairMethod.Method;
}
else if (genericType == typeof(SortedDictionary <,>))
{
method = GenericType2.Get(type.GetGenericArguments()).BinaryDeSerializeSortedDictionaryMemberMethod;
}
else if (genericType == typeof(SortedList <,>))
{
method = GenericType2.Get(type.GetGenericArguments()).BinaryDeSerializeSortedListMemberMethod;
}
}
if (method == null)
{
if (type.IsValueType)
{
method = StructGenericType.Get(type).BinaryDeSerializeStructMethod; // structDeSerializeMethod.MakeGenericMethod(type);
}
else
{
method = ClassGenericType.Get(type).BinaryDeSerializeMemberClassMethod; // memberClassDeSerializeMethod.MakeGenericMethod(type);
}
}
}
memberMethods.Set(type, method);
return(method);
}
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 = GenericType.Get(elementType).BinaryDeSerializeEnumUIntArrayMethod; // DeSerializeMethodCache.EnumUIntArrayMethod.MakeGenericMethod(elementType);
}
else if (enumType == typeof(byte))
{
methodInfo = GenericType.Get(elementType).BinaryDeSerializeEnumByteArrayMethod; // DeSerializeMethodCache.EnumByteArrayMethod.MakeGenericMethod(elementType);
}
else if (enumType == typeof(ulong))
{
methodInfo = GenericType.Get(elementType).BinaryDeSerializeEnumULongArrayMethod; // DeSerializeMethodCache.EnumULongArrayMethod.MakeGenericMethod(elementType);
}
else if (enumType == typeof(ushort))
{
methodInfo = GenericType.Get(elementType).BinaryDeSerializeEnumUShortArrayMethod; // DeSerializeMethodCache.EnumUShortArrayMethod.MakeGenericMethod(elementType);
}
else if (enumType == typeof(long))
{
methodInfo = GenericType.Get(elementType).BinaryDeSerializeEnumLongArrayMethod; // DeSerializeMethodCache.EnumLongArrayMethod.MakeGenericMethod(elementType);
}
else if (enumType == typeof(short))
{
methodInfo = GenericType.Get(elementType).BinaryDeSerializeEnumShortArrayMethod; // DeSerializeMethodCache.EnumShortArrayMethod.MakeGenericMethod(elementType);
}
else if (enumType == typeof(sbyte))
{
methodInfo = GenericType.Get(elementType).BinaryDeSerializeEnumSByteArrayMethod; // DeSerializeMethodCache.EnumSByteArrayMethod.MakeGenericMethod(elementType);
}
else
{
methodInfo = GenericType.Get(elementType).BinaryDeSerializeEnumIntArrayMethod; // DeSerializeMethodCache.EnumIntArrayMethod.MakeGenericMethod(elementType);
}
IsReferenceMember = false;
}
else if (elementType.IsGenericType && elementType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
//methodInfo = DeSerializeMethodCache.NullableArrayMethod.MakeGenericMethod(elementType = elementType.GetGenericArguments()[0]);
methodInfo = StructGenericType.Get(elementType = elementType.GetGenericArguments()[0]).BinaryDeSerializeNullableArrayMethod;
IsReferenceMember = SerializeMethodCache.IsReferenceMember(elementType);
}
else
{
//methodInfo = DeSerializeMethodCache.StructArrayMethod.MakeGenericMethod(elementType);
methodInfo = GenericType.Get(elementType).BinaryDeSerializeStructArrayMethod;
IsReferenceMember = SerializeMethodCache.IsReferenceMember(elementType);
}
}
else
{
//methodInfo = DeSerializeMethodCache.ArrayMethod.MakeGenericMethod(elementType);
methodInfo = ClassGenericType.Get(elementType).BinaryDeSerializeArrayMethod;
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()));
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), GenericType.Get(type.GetGenericArguments()[0]).BinaryDeSerializeLeftArrayMethod);
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()));
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), GenericType.Get(type.GetGenericArguments()[0]).BinaryDeSerializeSubArrayMethod);
IsReferenceMember = SerializeMethodCache.IsReferenceMember(parameterTypes[0]);
isValueType = true;
return;
}
#endif
if (genericType == typeof(Dictionary <,>))
{
//DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.DictionaryDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), GenericType2.Get(type.GetGenericArguments()).BinaryDeSerializeDictionaryMethod);
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()));
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), StructGenericType.Get(type.GetGenericArguments()[0]).BinaryDeSerializeNullableMethod);
IsReferenceMember = SerializeMethodCache.IsReferenceMember(parameterTypes[0]);
isValueType = true;
return;
}
if (genericType == typeof(KeyValuePair <,>))
{
//DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.KeyValuePairDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), GenericType2.Get(type.GetGenericArguments()).BinaryDeSerializeKeyValuePairMethod);
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()));
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), GenericType2.Get(type.GetGenericArguments()).BinaryDeSerializeSortedDictionaryMethod);
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()));
DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), GenericType2.Get(type.GetGenericArguments()).BinaryDeSerializeSortedListMethod);
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);
if (type.IsValueType)
{
methodInfo = CollectionGenericType2.Get(type, argumentType).BinaryDeSerializeStructCollectionMethod;
}
else
{
methodInfo = CollectionGenericType2.Get(type, argumentType).BinaryDeSerializeClassCollectionMethod;
}
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);
if (type.IsValueType)
{
methodInfo = CollectionGenericType2.Get(type, argumentType).BinaryDeSerializeStructCollectionMethod;
}
else
{
methodInfo = CollectionGenericType2.Get(type, argumentType).BinaryDeSerializeClassCollectionMethod;
}
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);
if (type.IsValueType)
{
methodInfo = CollectionGenericType2.Get(type, argumentType).BinaryDeSerializeStructCollectionMethod;
}
else
{
methodInfo = CollectionGenericType2.Get(type, argumentType).BinaryDeSerializeClassCollectionMethod;
}
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);
if (type.IsValueType)
{
methodInfo = CollectionGenericType2.Get(type, argumentType).BinaryDeSerializeStructCollectionMethod;
}
else
{
methodInfo = CollectionGenericType2.Get(type, argumentType).BinaryDeSerializeClassCollectionMethod;
}
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]);
if (type.IsValueType)
{
methodInfo = DictionaryGenericType3.Get(type, parameters[0], parameters[1]).BinaryDeSerializeStructDictionaryMethod;
}
else
{
methodInfo = DictionaryGenericType3.Get(type, parameters[0], parameters[1]).BinaryDeSerializeClassDictionaryMethod;
}
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;
}
}
///// <summary>
///// 数组转换函数信息
///// </summary>
//private static readonly MethodInfo enumByteArrayMemberMethod = typeof(Serializer).GetMethod("enumByteArrayMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 数组转换函数信息
///// </summary>
//private static readonly MethodInfo enumSByteArrayMemberMethod = typeof(Serializer).GetMethod("enumSByteArrayMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 数组转换函数信息
///// </summary>
//private static readonly MethodInfo enumShortArrayMemberMethod = typeof(Serializer).GetMethod("enumShortArrayMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 数组转换函数信息
///// </summary>
//private static readonly MethodInfo enumUShortArrayMemberMethod = typeof(Serializer).GetMethod("enumUShortArrayMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 数组转换函数信息
///// </summary>
//private static readonly MethodInfo enumIntArrayMemberMethod = typeof(Serializer).GetMethod("enumIntArrayMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 数组转换函数信息
///// </summary>
//private static readonly MethodInfo enumUIntArrayMemberMethod = typeof(Serializer).GetMethod("enumUIntArrayMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 数组转换函数信息
///// </summary>
//private static readonly MethodInfo enumLongArrayMemberMethod = typeof(Serializer).GetMethod("enumLongArrayMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 数组转换函数信息
///// </summary>
//private static readonly MethodInfo enumULongArrayMemberMethod = typeof(Serializer).GetMethod("enumULongArrayMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 数组转换函数信息
///// </summary>
//private static readonly MethodInfo nullableArrayMemberMethod = typeof(Serializer).GetMethod("nullableArrayMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 数组转换函数信息
///// </summary>
//private static readonly MethodInfo structArrayMemberMethod = typeof(Serializer).GetMethod("structArrayMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 数组转换函数信息
///// </summary>
//private static readonly MethodInfo arrayMemberMethod = typeof(Serializer).GetMethod("arrayMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 枚举转换函数信息
///// </summary>
//private static readonly MethodInfo enumByteMemberMethod = typeof(Serializer).GetMethod("enumByteMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 枚举转换函数信息
///// </summary>
//private static readonly MethodInfo enumSByteMemberMethod = typeof(Serializer).GetMethod("enumSByteMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 枚举转换函数信息
///// </summary>
//private static readonly MethodInfo enumShortMemberMethod = typeof(Serializer).GetMethod("enumShortMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 枚举转换函数信息
///// </summary>
//private static readonly MethodInfo enumUShortMemberMethod = typeof(Serializer).GetMethod("enumUShortMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 枚举转换函数信息
///// </summary>
//private static readonly MethodInfo enumIntMemberMethod = typeof(Serializer).GetMethod("enumIntMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 枚举转换函数信息
///// </summary>
//private static readonly MethodInfo enumUIntMemberMethod = typeof(Serializer).GetMethod("enumUIntMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 枚举转换函数信息
///// </summary>
//private static readonly MethodInfo enumLongMemberMethod = typeof(Serializer).GetMethod("enumLongMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 枚举转换函数信息
///// </summary>
//private static readonly MethodInfo enumULongMemberMethod = typeof(Serializer).GetMethod("enumULongMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 字典序列化函数信息
///// </summary>
//private static readonly MethodInfo dictionaryMemberMethod = typeof(Serializer).GetMethod("dictionaryMember", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 对象序列化函数信息
///// </summary>
//private static readonly MethodInfo nullableMemberSerializeMethod = typeof(Serializer).GetMethod("nullableMemberSerialize", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 对象序列化函数信息
///// </summary>
//private static readonly MethodInfo structSerializeMethod = typeof(Serializer).GetMethod("structSerialize", BindingFlags.Instance | BindingFlags.NonPublic);
///// <summary>
///// 引用类型成员序列化函数信息
///// </summary>
//private static readonly MethodInfo memberClassSerializeMethod = typeof(Serializer).GetMethod("MemberClassSerialize", BindingFlags.Instance | BindingFlags.NonPublic);
/// <summary>
/// 未知类型枚举序列化委托调用函数信息
/// </summary>
/// <param name="type">数组类型</param>
/// <returns>未知类型序列化委托调用函数信息</returns>
public static MethodInfo GetMember(Type type)
{
MethodInfo method;
if (memberMethods.TryGetValue(type, out method))
{
return(method);
}
if (type.IsArray)
{
Type elementType = type.GetElementType();
if (elementType.IsValueType)
{
if (elementType.IsEnum)
{
Type enumType = System.Enum.GetUnderlyingType(elementType);
if (enumType == typeof(uint))
{
method = GenericType.Get(elementType).BinarySerializeEnumUIntArrayMemberMethod; // enumUIntArrayMemberMethod;
}
else if (enumType == typeof(byte))
{
method = GenericType.Get(elementType).BinarySerializeEnumByteArrayMemberMethod; // enumByteArrayMemberMethod;
}
else if (enumType == typeof(ulong))
{
method = GenericType.Get(elementType).BinarySerializeEnumULongArrayMemberMethod; // enumULongArrayMemberMethod;
}
else if (enumType == typeof(ushort))
{
method = GenericType.Get(elementType).BinarySerializeEnumUShortArrayMemberMethod; // enumUShortArrayMemberMethod;
}
else if (enumType == typeof(long))
{
method = GenericType.Get(elementType).BinarySerializeEnumLongArrayMemberMethod; // enumLongArrayMemberMethod;
}
else if (enumType == typeof(short))
{
method = GenericType.Get(elementType).BinarySerializeEnumShortArrayMemberMethod; // enumShortArrayMemberMethod;
}
else if (enumType == typeof(sbyte))
{
method = GenericType.Get(elementType).BinarySerializeEnumSByteArrayMemberMethod; // enumSByteArrayMemberMethod;
}
else
{
method = GenericType.Get(elementType).BinarySerializeEnumIntArrayMemberMethod; // enumIntArrayMemberMethod;
}
//method = method.MakeGenericMethod(elementType);
}
else if (elementType.IsGenericType && elementType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
//method = nullableArrayMemberMethod.MakeGenericMethod(elementType.GetGenericArguments());
method = StructGenericType.Get(elementType.GetGenericArguments()[0]).BinarySerializeNullableArrayMemberMethod;
}
//else method = structArrayMemberMethod.MakeGenericMethod(elementType);
else
{
method = GenericType.Get(elementType).BinarySerializeStructArrayMemberMethod;
}
}
//else method = arrayMemberMethod.MakeGenericMethod(elementType);
else
{
method = ClassGenericType.Get(elementType).BinarySerializeArrayMemberMethod;
}
}
else if (type.IsEnum)
{
Type enumType = System.Enum.GetUnderlyingType(type);
if (enumType == typeof(uint))
{
method = GenericType.Get(type).BinarySerializeEnumUIntMemberMethod; // enumUIntMemberMethod;
}
else if (enumType == typeof(byte))
{
method = GenericType.Get(type).BinarySerializeEnumByteMemberMethod; // enumByteMemberMethod;
}
else if (enumType == typeof(ulong))
{
method = GenericType.Get(type).BinarySerializeEnumULongMemberMethod; // enumULongMemberMethod;
}
else if (enumType == typeof(ushort))
{
method = GenericType.Get(type).BinarySerializeEnumUShortMemberMethod; // enumUShortMemberMethod;
}
else if (enumType == typeof(long))
{
method = GenericType.Get(type).BinarySerializeEnumLongMemberMethod; // enumLongMemberMethod;
}
else if (enumType == typeof(short))
{
method = GenericType.Get(type).BinarySerializeEnumShortMemberMethod; // enumShortMemberMethod;
}
else if (enumType == typeof(sbyte))
{
method = GenericType.Get(type).BinarySerializeEnumSByteMemberMethod; // enumSByteMemberMethod;
}
else
{
method = GenericType.Get(type).BinarySerializeEnumIntMemberMethod; // enumIntMemberMethod;
}
//method = method.MakeGenericMethod(type);
}
else
{
if (type.IsGenericType)
{
Type genericType = type.GetGenericTypeDefinition();
if (genericType == typeof(Dictionary <,>) || genericType == typeof(SortedDictionary <,>) || genericType == typeof(SortedList <,>))
{
Type[] parameterTypes = type.GetGenericArguments();
//method = dictionaryMemberMethod.MakeGenericMethod(type, parameterTypes[0], parameterTypes[1]);
method = DictionaryGenericType3.Get(type, parameterTypes[0], parameterTypes[1]).BinarySerializeDictionaryMemberMethod;
}
else if (genericType == typeof(Nullable <>))
{
//method = nullableMemberSerializeMethod.MakeGenericMethod(type.GetGenericArguments());
method = StructGenericType.Get(type.GetGenericArguments()[0]).BinarySerializeNullableMemberMethod;
}
else if (genericType == typeof(KeyValuePair <,>))
{
//method = KeyValuePairSerializeMethod.MakeGenericMethod(type.GetGenericArguments());
method = GenericType2.Get(type.GetGenericArguments()).BinarySerializeKeyValuePairMethod;
}
}
if (method == null)
{
//if (type.IsValueType) method = structSerializeMethod.MakeGenericMethod(type);
//else method = memberClassSerializeMethod.MakeGenericMethod(type);
if (type.IsValueType)
{
method = StructGenericType.Get(type).BinarySerializeStructMethod;
}
else
{
method = ClassGenericType.Get(type).BinarySerializeMemberClassMethod;
}
}
}
memberMethods.Set(type, method);
return(method);
}
/// <summary>
/// 未知类型枚举序列化委托调用函数信息
/// </summary>
/// <param name="type">数组类型</param>
/// <returns>未知类型序列化委托调用函数信息</returns>
public static MethodInfo GetMember(Type type)
{
MethodInfo method;
if (memberMethods.TryGetValue(type, out method))
{
return(method);
}
if (type.IsArray)
{
Type elementType = type.GetElementType();
if (elementType.IsValueType)
{
if (elementType.IsEnum)
{
method = EnumGenericType.Get(elementType).BinarySerializeEnumArrayMemberDelegate.Method;
}
else if (elementType.IsGenericType && elementType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
//method = nullableArrayMemberMethod.MakeGenericMethod(elementType.GetGenericArguments());
method = StructGenericType.Get(elementType.GetGenericArguments()[0]).BinarySerializeNullableArrayMemberMethod;
}
//else method = structArrayMemberMethod.MakeGenericMethod(elementType);
else
{
method = GenericType.Get(elementType).BinarySerializeStructArrayMemberMethod;
}
}
//else method = arrayMemberMethod.MakeGenericMethod(elementType);
else
{
method = ClassGenericType.Get(elementType).BinarySerializeArrayMemberMethod;
}
}
else if (type.IsEnum)
{
method = (EnumGenericType.Get(type).BinarySerializeEnumMemberDelegate).Method;
}
else
{
if (type.IsGenericType)
{
Type genericType = type.GetGenericTypeDefinition();
if (genericType == typeof(Dictionary <,>) || genericType == typeof(SortedDictionary <,>) || genericType == typeof(SortedList <,>))
{
Type[] parameterTypes = type.GetGenericArguments();
//method = dictionaryMemberMethod.MakeGenericMethod(type, parameterTypes[0], parameterTypes[1]);
method = DictionaryGenericType3.Get(type, parameterTypes[0], parameterTypes[1]).BinarySerializeDictionaryMemberMethod;
}
else if (genericType == typeof(Nullable <>))
{
//method = nullableMemberSerializeMethod.MakeGenericMethod(type.GetGenericArguments());
method = StructGenericType.Get(type.GetGenericArguments()[0]).BinarySerializeNullableMemberMethod;
}
else if (genericType == typeof(KeyValuePair <,>))
{
//method = KeyValuePairSerializeMethod.MakeGenericMethod(type.GetGenericArguments());
method = GenericType2.Get(type.GetGenericArguments()).BinarySerializeKeyValuePairMethod.Method;
}
}
if (method == null)
{
//if (type.IsValueType) method = structSerializeMethod.MakeGenericMethod(type);
//else method = memberClassSerializeMethod.MakeGenericMethod(type);
if (type.IsValueType)
{
method = StructGenericType.Get(type).BinarySerializeStructMethod;
}
else
{
method = ClassGenericType.Get(type).BinarySerializeMemberClassMethod;
}
}
}
memberMethods.Set(type, method);
return(method);
}