Beispiel #1
0
 public static AquaTypeModel ConfigureAquaTypeSystemTypes(this AquaTypeModel typeModel)
 => typeModel
 .AddType <TypeInfo>()
 .AddType <MemberInfo>()
 .AddSubType <MemberInfo, PropertyInfo>()
 .AddSubType <MemberInfo, FieldInfo>()
 .AddSubType <MemberInfo, MethodBaseInfo>()
 .AddSubType <MethodBaseInfo, MethodInfo>()
 .AddSubType <MethodBaseInfo, ConstructorInfo>();
Beispiel #2
0
        public static AquaTypeModel ConfigureAquaTypes(this RuntimeTypeModel typeModel, bool configureDefaultSystemTypes = true)
        {
            var aquaTypeModel = new AquaTypeModel(typeModel);

            if (configureDefaultSystemTypes)
            {
                ConfigureDefaultSystemTypes(aquaTypeModel);
            }

            return(aquaTypeModel
                   .ConfigureAquaTypeSystemTypes()
                   .ConfigureAquaDynamicTypes());
        }
        /// <summary>Register a base class and it's subtypes from the same assebly, uncluding all their serializable fields and proeprties.</summary>
        private static AquaTypeModel RegisterBaseAndSubtypes <T>(this AquaTypeModel typeModel)
        {
            var resiteredTypes = new HashSet <Type>();
            var pendingTypes   = new HashSet <Type>();

            void CollectType(Type t)
            {
                t = TypeHelper.GetElementType(t);

                if (resiteredTypes.Contains(t) || pendingTypes.Contains(t))
                {
                    return;
                }

                pendingTypes.Add(t);
                t.GetDefaultPropertiesForSerialization().Select(x => x.PropertyType).ForEach(CollectType);
                t.GetDefaultFieldsForSerialization().Select(x => x.FieldType).ForEach(CollectType);
            }

            void RegisterBaseAndSubtypes(Type baseType)
            {
                if (resiteredTypes.Contains(baseType))
                {
                    return;
                }

                resiteredTypes.Add(baseType);

                var expressionTypes = baseType.Assembly
                                      .GetTypes()
                                      .Where(x => x.BaseType == baseType)
                                      .OrderBy(x => x.FullName)
                                      .ToArray();

                foreach (var t in expressionTypes)
                {
                    typeModel.AddSubType(baseType, t);
                    RegisterBaseAndSubtypes(t);
                    CollectType(t);
                }
            }

            RegisterBaseAndSubtypes(typeof(T));

            pendingTypes.ForEach(x => _ = typeModel.GetType(x));

            return(typeModel);
        }
Beispiel #4
0
 public static AquaTypeModel ConfigureRemoteLinqDynamicQueryTypes(this AquaTypeModel typeModel)
 => typeModel
 .AddTypeSurrogate <ConstantQueryArgument, ConstantQueryArgumentSurrogate>()
 .AddType <QueryableResourceDescriptor>()
 .AddTypeSurrogate <VariableQueryArgument, VariableQueryArgumentSurrogate>()
 .AddTypeSurrogate <VariableQueryArgumentList, VariableQueryArgumentListSurrogate>();
Beispiel #5
0
 private static void ConfigureDefaultSystemTypes(AquaTypeModel typeModel)
 => _systemTypes.ForEach(t => typeModel.AddDynamicPropertyType(t));
 public static AquaTypeModel ConfigureRemoteLinqExpressionTypes(this AquaTypeModel typeModel)
 => typeModel
 .RegisterBaseAndSubtypes <MemberBinding>()
 .RegisterBaseAndSubtypes <Expression>()
 .AddTypeSurrogate <ConstantExpression, ConstantExpressionSurrogate>();
Beispiel #7
0
 public static AquaTypeModel ConfigureAquaDynamicTypes(this AquaTypeModel typeModel)
 => typeModel
 .AddTypeSurrogate <DynamicObject, DynamicObjectSurrogate>()
 .AddTypeSurrogate <Property, PropertySurrogate>()
 .AddType <PropertySet>()
 .AddType <DynamicObjectArraySurrogate>(t => t[1].SupportNull = true);