Ejemplo n.º 1
0
 /// <summary>
 /// 序列化接口
 /// </summary>
 /// <typeparam name="valueType">数据类型</typeparam>
 /// <param name="input">输入数据</param>
 /// <returns>输入数据</returns>
 private static deSerialize <valueType> .serializeOutput getISerializeType <valueType>(serializeInput input) where valueType : ISerialize
 {
     deSerialize <valueType> .serializeOutput output = new deSerialize <valueType> .serializeOutput {
         Value = fastCSharp.emit.constructor <valueType> .New()
     };
     output.Value.DeIndexSerialize(input.Data, out output.EndIndex, out output.MemberMap, input.MemberIndexs);
     return(output);
 }
Ejemplo n.º 2
0
            /// <summary>
            /// 可空类型
            /// </summary>
            /// <typeparam name="valueType">数据类型</typeparam>
            /// <param name="serializer">反序列化器</param>
            /// <returns>可空类型数据</returns>
            private static deSerialize <Nullable <valueType> > .serializeOutput getNullType <valueType>(serializeInput input) where valueType : struct
            {
                deSerialize <Nullable <valueType> > .serializeOutput output = new deSerialize <Nullable <valueType> > .serializeOutput {
                };
                valueType             value = default(valueType);
                memberMap <valueType> memberMap;

                if (Get <valueType>(ref value, input.Data, out output.EndIndex, out memberMap, input.MemberIndexs))
                {
                    output.Value     = value;
                    output.MemberMap = memberMap;
                }
                return(output);
            }
Ejemplo n.º 3
0
        /// <summary>
        /// 二进制数据反序列化
        /// </summary>
        /// <param name="globalVersion"></param>
        /// <param name="fields"></param>
        /// <param name="memberCountVerify"></param>
        internal TypeDeSerializer(uint globalVersion, ref Fields <FieldSize> fields, int memberCountVerify)
        {
            Type type = typeof(valueType);

            this.globalVersion     = globalVersion;
            this.memberCountVerify = memberCountVerify;
            fixedFillSize          = -fields.FixedSize & 3;
#if NOJIT
            fixedMemberDeSerializer = new FieldDeSerializer(ref fields.FixedFields).DeSerialize;
            if (isMemberMap)
            {
                fixedMemberMapDeSerializer = new MemberMapDeSerializer(ref fields.FixedFields).DeSerialize;
            }
            if (fields.FieldArray.Length != 0)
            {
                memberDeSerializer = new FieldDeSerializer(ref fields.FieldArray).DeSerialize;
                if (isMemberMap)
                {
                    memberMapDeSerializer = new MemberMapDeSerializer(ref fields.FieldArray).DeSerialize;
                }
            }
#else
            DeSerializeMemberDynamicMethod    fixedDynamicMethod          = new DeSerializeMemberDynamicMethod(type);
            DeSerializeMemberMapDynamicMethod fixedMemberMapDynamicMethod = isMemberMap ? new DeSerializeMemberMapDynamicMethod(type) : default(DeSerializeMemberMapDynamicMethod);
            foreach (FieldSize member in fields.FixedFields)
            {
                fixedDynamicMethod.Push(member);
                if (isMemberMap)
                {
                    fixedMemberMapDynamicMethod.Push(member);
                }
            }
            fixedMemberDeSerializer = (deSerialize)fixedDynamicMethod.Create <deSerialize>();
            if (isMemberMap)
            {
                fixedMemberMapDeSerializer = (memberMapDeSerialize)fixedMemberMapDynamicMethod.Create <memberMapDeSerialize>();
            }

            if (fields.FieldArray.Length != 0)
            {
                DeSerializeMemberDynamicMethod    dynamicMethod          = new DeSerializeMemberDynamicMethod(type);
                DeSerializeMemberMapDynamicMethod memberMapDynamicMethod = isMemberMap ? new DeSerializeMemberMapDynamicMethod(type) : default(DeSerializeMemberMapDynamicMethod);
                foreach (FieldSize member in fields.FieldArray)
                {
                    dynamicMethod.Push(member);
                    if (isMemberMap)
                    {
                        memberMapDynamicMethod.Push(member);
                    }
                }
                memberDeSerializer = (deSerialize)dynamicMethod.Create <deSerialize>();
                if (isMemberMap)
                {
                    memberMapDeSerializer = (memberMapDeSerialize)memberMapDynamicMethod.Create <memberMapDeSerialize>();
                }
            }
#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);
                }
            }
        }
Ejemplo n.º 4
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 = DeSerializeMethodCache.EnumUIntArrayMethod.MakeGenericMethod(elementType);
                                }
                                else if (enumType == typeof(byte))
                                {
                                    methodInfo = DeSerializeMethodCache.EnumByteArrayMethod.MakeGenericMethod(elementType);
                                }
                                else if (enumType == typeof(ulong))
                                {
                                    methodInfo = DeSerializeMethodCache.EnumULongArrayMethod.MakeGenericMethod(elementType);
                                }
                                else if (enumType == typeof(ushort))
                                {
                                    methodInfo = DeSerializeMethodCache.EnumUShortArrayMethod.MakeGenericMethod(elementType);
                                }
                                else if (enumType == typeof(long))
                                {
                                    methodInfo = DeSerializeMethodCache.EnumLongArrayMethod.MakeGenericMethod(elementType);
                                }
                                else if (enumType == typeof(short))
                                {
                                    methodInfo = DeSerializeMethodCache.EnumShortArrayMethod.MakeGenericMethod(elementType);
                                }
                                else if (enumType == typeof(sbyte))
                                {
                                    methodInfo = DeSerializeMethodCache.EnumSByteArrayMethod.MakeGenericMethod(elementType);
                                }
                                else
                                {
                                    methodInfo = DeSerializeMethodCache.EnumIntArrayMethod.MakeGenericMethod(elementType);
                                }
                                IsReferenceMember = false;
                            }
                            else if (elementType.IsGenericType && elementType.GetGenericTypeDefinition() == typeof(Nullable <>))
                            {
                                methodInfo        = DeSerializeMethodCache.NullableArrayMethod.MakeGenericMethod(elementType = elementType.GetGenericArguments()[0]);
                                IsReferenceMember = SerializeMethodCache.IsReferenceMember(elementType);
                            }
                            else
                            {
                                methodInfo        = DeSerializeMethodCache.StructArrayMethod.MakeGenericMethod(elementType);
                                IsReferenceMember = SerializeMethodCache.IsReferenceMember(elementType);
                            }
                        }
                        else
                        {
                            methodInfo        = DeSerializeMethodCache.ArrayMethod.MakeGenericMethod(elementType);
                            IsReferenceMember = SerializeMethodCache.IsReferenceMember(elementType);
                        }
                        DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), methodInfo);
                        return;
                    }
                }
                DefaultDeSerializer = fromNull;
                IsReferenceMember   = false;
                return;
            }
            if (type.IsEnum)
            {
                Type enumType = System.Enum.GetUnderlyingType(type);
                if (enumType == typeof(uint))
                {
                    DefaultDeSerializer = enumUInt;
                }
                else if (enumType == typeof(byte))
                {
                    DefaultDeSerializer = enumByte;
                }
                else if (enumType == typeof(ulong))
                {
                    DefaultDeSerializer = enumULong;
                }
                else if (enumType == typeof(ushort))
                {
                    DefaultDeSerializer = enumUShort;
                }
                else if (enumType == typeof(long))
                {
                    DefaultDeSerializer = enumLong;
                }
                else if (enumType == typeof(short))
                {
                    DefaultDeSerializer = enumShort;
                }
                else if (enumType == typeof(sbyte))
                {
                    DefaultDeSerializer = enumSByte;
                }
                else
                {
                    DefaultDeSerializer = enumInt;
                }
                IsReferenceMember = false;
                isValueType       = true;
                return;
            }
            if (type.IsPointer || typeof(Delegate).IsAssignableFrom(type))
            {
                DefaultDeSerializer = fromNull;
                IsReferenceMember   = false;
                isValueType         = true;
                return;
            }
            if (type.IsGenericType)
            {
                Type   genericType    = type.GetGenericTypeDefinition();
                Type[] parameterTypes = type.GetGenericArguments();
                if (genericType == typeof(LeftArray <>))
                {
                    DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.LeftArrayDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
                    IsReferenceMember   = SerializeMethodCache.IsReferenceMember(parameterTypes[0]);
                    isValueType         = true;
                    return;
                }
#if !Serialize
                if (genericType == typeof(SubArray <>))
                {
                    DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.SubArrayDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
                    IsReferenceMember   = SerializeMethodCache.IsReferenceMember(parameterTypes[0]);
                    isValueType         = true;
                    return;
                }
#endif
                if (genericType == typeof(Dictionary <,>))
                {
                    DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.DictionaryDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
                    IsReferenceMember   = SerializeMethodCache.IsReferenceMember(parameterTypes[0]) || SerializeMethodCache.IsReferenceMember(parameterTypes[1]);
                    isValueType         = true;
                    return;
                }
                if (genericType == typeof(Nullable <>))
                {
                    DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.NullableDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
                    IsReferenceMember   = SerializeMethodCache.IsReferenceMember(parameterTypes[0]);
                    isValueType         = true;
                    return;
                }
                if (genericType == typeof(KeyValuePair <,>))
                {
                    DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.KeyValuePairDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
                    IsReferenceMember   = SerializeMethodCache.IsReferenceMember(parameterTypes[0]) || SerializeMethodCache.IsReferenceMember(parameterTypes[1]);
                    isValueType         = true;
                    return;
                }
                if (genericType == typeof(SortedDictionary <,>))
                {
                    DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.SortedDictionaryDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
                    IsReferenceMember   = SerializeMethodCache.IsReferenceMember(parameterTypes[0]) || SerializeMethodCache.IsReferenceMember(parameterTypes[1]);
                    isValueType         = true;
                    return;
                }
                if (genericType == typeof(SortedList <,>))
                {
                    DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), DeSerializeMethodCache.SortedListDeSerializeMethod.MakeGenericMethod(type.GetGenericArguments()));
                    IsReferenceMember   = SerializeMethodCache.IsReferenceMember(parameterTypes[0]) || SerializeMethodCache.IsReferenceMember(parameterTypes[1]);
                    isValueType         = true;
                    return;
                }
            }
            if ((methodInfo = SerializeMethodCache.GetCustom(type, false)) != null)
            {
                if (type.IsValueType)
                {
#if NOJIT
                    DefaultDeSerializer = new CustomDeSerializer(methodInfo).DeSerialize;
#else
                    DynamicMethod dynamicMethod = new DynamicMethod("CustomDeSerializer", null, new Type[] { typeof(DeSerializer), type.MakeByRefType() }, type, true);
                    ILGenerator   generator     = dynamicMethod.GetILGenerator();
                    generator.Emit(OpCodes.Ldarg_1);
                    generator.Emit(OpCodes.Ldarg_0);
                    generator.call(methodInfo);
                    generator.Emit(OpCodes.Ret);
                    DefaultDeSerializer = (deSerialize)dynamicMethod.CreateDelegate(typeof(deSerialize));
#endif
                }
                else
                {
                    DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), methodInfo);
                }
                IsReferenceMember = attribute.IsReferenceMember;
                isValueType       = true;
                return;
            }
            if (type.IsAbstract || type.IsInterface || Emit.Constructor <valueType> .New == null)
            {
                DefaultDeSerializer = noConstructor;
                isValueType         = IsReferenceMember = true;
                return;
            }
            IsReferenceMember = attribute.IsReferenceMember;
            foreach (Type interfaceType in type.GetInterfaces())
            {
                if (interfaceType.IsGenericType)
                {
                    Type genericType = interfaceType.GetGenericTypeDefinition();
                    if (genericType == typeof(ICollection <>))
                    {
                        Type[] parameters   = interfaceType.GetGenericArguments();
                        Type   argumentType = parameters[0];
                        parameters[0] = argumentType.MakeArrayType();
                        ConstructorInfo constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, parameters, null);
                        if (constructorInfo != null)
                        {
                            methodInfo = (type.IsValueType ? DeSerializeMethodCache.StructCollectionMethod : DeSerializeMethodCache.ClassCollectionMethod).MakeGenericMethod(type, argumentType);
                            break;
                        }
                        parameters[0]   = typeof(IList <>).MakeGenericType(argumentType);
                        constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, parameters, null);
                        if (constructorInfo != null)
                        {
                            methodInfo = (type.IsValueType ? DeSerializeMethodCache.StructCollectionMethod : DeSerializeMethodCache.ClassCollectionMethod).MakeGenericMethod(type, argumentType);
                            break;
                        }
                        parameters[0]   = typeof(ICollection <>).MakeGenericType(argumentType);
                        constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, parameters, null);
                        if (constructorInfo != null)
                        {
                            methodInfo = (type.IsValueType ? DeSerializeMethodCache.StructCollectionMethod : DeSerializeMethodCache.ClassCollectionMethod).MakeGenericMethod(type, argumentType);
                            break;
                        }
                        parameters[0]   = typeof(IEnumerable <>).MakeGenericType(argumentType);
                        constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, parameters, null);
                        if (constructorInfo != null)
                        {
                            methodInfo = (type.IsValueType ? DeSerializeMethodCache.StructCollectionMethod : DeSerializeMethodCache.ClassCollectionMethod).MakeGenericMethod(type, argumentType);
                            break;
                        }
                    }
                    else if (genericType == typeof(IDictionary <,>))
                    {
                        ConstructorInfo constructorInfo = type.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { interfaceType }, null);
                        if (constructorInfo != null)
                        {
                            Type[] parameters = interfaceType.GetGenericArguments();
                            methodInfo = (type.IsValueType ? DeSerializeMethodCache.StructDictionaryDeSerializeMethod : DeSerializeMethodCache.ClassDictionaryDeSerializeMethod).MakeGenericMethod(type, parameters[0], parameters[1]);
                            break;
                        }
                    }
                }
            }
            if (methodInfo != null)
            {
                DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), methodInfo);
                return;
            }
            if (type.IsValueType)
            {
                isValueType = true;
            }
            else if (attribute != Serializer.DefaultAttribute && attributeType != type)
            {
                for (Type baseType = type.BaseType; baseType != typeof(object); baseType = baseType.BaseType)
                {
                    SerializeAttribute baseAttribute = baseType.customAttribute <SerializeAttribute>();
                    if (baseAttribute != null)
                    {
                        if (baseAttribute.IsBaseType)
                        {
                            methodInfo          = DeSerializeMethodCache.BaseSerializeMethod.MakeGenericMethod(baseType, type);
                            DefaultDeSerializer = (deSerialize)Delegate.CreateDelegate(typeof(deSerialize), methodInfo);
                            return;
                        }
                        break;
                    }
                }
            }

            LeftArray <DeSerializeVersionField> attributeFields = new LeftArray <DeSerializeVersionField>();
            if ((attribute.MemberFilters & MemberFilters.PublicInstanceField) != 0)
            {
                appendField(ref attributeFields, MemberIndexGroup <valueType> .Group.PublicFields);
            }
            else
            {
                foreach (FieldIndex field in MemberIndexGroup <valueType> .Group.PublicFields)
                {
                    attributeFields.Add(new DeSerializeVersionField {
                        Field = field
                    });
                }
            }
            if ((attribute.MemberFilters & MemberFilters.NonPublicInstanceField) != 0)
            {
                appendField(ref attributeFields, MemberIndexGroup <valueType> .Group.NonPublicFields);
            }
            if (attribute.IsAnonymousFields)
            {
                appendField(ref attributeFields, MemberIndexGroup <valueType> .Group.AnonymousFields);
            }
            foreach (FieldIndex field in new MemberIndexGroup(type, true).NonPublicFields)
            {
                Type fieldType = field.Member.FieldType;
                if (!fieldType.IsPointer && (!fieldType.IsArray || fieldType.GetArrayRank() == 1) && !field.IsIgnore && !typeof(Delegate).IsAssignableFrom(fieldType))
                {
                    SerializeMemberAttribute memberAttribute = field.GetAttribute <SerializeMemberAttribute>(true);
                    if (memberAttribute != null && memberAttribute.IsSetup && memberAttribute.RemoveGlobalVersion != memberAttribute.GlobalVersion)
                    {
                        attributeFields.Add(new DeSerializeVersionField {
                            Field = field, Attribute = memberAttribute
                        });
                        if (memberAttribute.IsRemove)
                        {
                            attributeFields.Add(new DeSerializeVersionField {
                                Field = field, Attribute = memberAttribute, IsRemove = true
                            });
                        }
                    }
                }
            }

            isMemberMap = attribute.GetIsMemberMap;
            isJson      = attribute.GetIsJson;
            uint globalVersion = 0, removeMemberCount = 0;
            int  noSerializeMemberCount = 0;
            LeftArray <DeSerializeVersionFields <valueType> > deSerializeVersionFields = default(LeftArray <DeSerializeVersionFields <valueType> >);
            LeftArray <DeSerializeVersionField> attributeVersionFields = new LeftArray <DeSerializeVersionField>(attributeFields.Length);
            foreach (DeSerializeVersionField field in attributeFields.Sort(DeSerializeVersionField.GlobalVersionSort))
            {
                if (field.GlobalVersion != globalVersion)
                {
                    deSerializeVersionFields.Add(new DeSerializeVersionFields <valueType>(globalVersion, attributeVersionFields.GetArray(), removeMemberCount, noSerializeMemberCount));
                    globalVersion = field.GlobalVersion;
                }
                if (field.IsRemove)
                {
                    attributeVersionFields.RemoveToEnd(value => object.ReferenceEquals(value.Field, field.Field));
                    if (field.Attribute.IsRemove)
                    {
                        --removeMemberCount;
                    }
                }
                else
                {
                    attributeVersionFields.Add(field);
                    if (field.Attribute != null)
                    {
                        if (field.Attribute.IsRemove)
                        {
                            ++removeMemberCount;
                        }
                    }
                    else
                    {
                        ++noSerializeMemberCount;
                    }
                }
            }
            fieldDeSerializer = new DeSerializeVersionFields <valueType>(globalVersion, attributeVersionFields.GetArray(), removeMemberCount, noSerializeMemberCount).CreateOnly(attribute);
            if (deSerializeVersionFields.Length != 0)
            {
                int count = deSerializeVersionFields.Length;
                DeSerializeVersionFields <valueType>[] deSerializeVersionFieldsArray = new DeSerializeVersionFields <valueType> [count];
                foreach (DeSerializeVersionFields <valueType> value in deSerializeVersionFields)
                {
                    deSerializeVersionFieldsArray[--count]          = value;
                    deSerializeVersionFieldsArray[count].CreateLock = new object();
                }
                fieldDeSerializers = deSerializeVersionFieldsArray;
            }
        }