예제 #1
0
        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);
                }
            }
        }
예제 #2
0
        /// <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);
        }
예제 #3
0
        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;
            }
        }
예제 #4
0
        ///// <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);
        }
예제 #5
0
        /// <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);
        }