Beispiel #1
0
        /// <summary>
        /// Creates an instance of Mapper for collections.
        /// </summary>
        /// <param name="MapperName">Mapper name. It is used for registration in Mappers repositories.</param>
        /// <param name="mapperMannager">Mappers manager</param>
        /// <param name="TypeFrom">Source type</param>
        /// <param name="TypeTo">Destination type</param>
        /// <param name="SubMapper"></param>
        /// <returns></returns>
        public static MapperForCollectionImpl CreateInstance(
            string MapperName,
            ObjectMapperManager mapperMannager,
            Type TypeFrom,
            Type TypeTo,
            ObjectsMapperDescr SubMapper,
            IMappingConfigurator mappingConfigurator
            )
        {
            TypeBuilder tb = DynamicAssemblyManager.DefineType(
                "GenericListInv_" + MapperName,
                typeof(MapperForCollectionImpl)
                );

            if (TypeTo.IsGenericType() && TypeTo.GetGenericTypeDefinition() == typeof(List <>))
            {
                MethodBuilder methodBuilder = tb.DefineMethod(
                    "CopyToListInvoke",
                    MethodAttributes.Family | MethodAttributes.Virtual,
                    typeof(object),
                    new Type[] { typeof(IEnumerable) }
                    );

                InvokeCopyImpl(TypeTo, "CopyToList").Compile(new CompilationContext(methodBuilder.GetILGenerator()));

                methodBuilder = tb.DefineMethod(
                    "CopyToListScalarInvoke",
                    MethodAttributes.Family | MethodAttributes.Virtual,
                    typeof(object),
                    new Type[] { typeof(object) }
                    );

                InvokeCopyImpl(TypeTo, "CopyToListScalar").Compile(
                    new CompilationContext(methodBuilder.GetILGenerator())
                    );
            }

            MapperForCollectionImpl result = (MapperForCollectionImpl)Activator.CreateInstance(tb.CreateTypeInfo().AsType());

            result.Initialize(mapperMannager, TypeFrom, TypeTo, mappingConfigurator, null);
            result.subMapper = SubMapper;

            return(result);
        }
Beispiel #2
0
        private IAstRefOrValue ConvertByMapper(ReadWriteSimple mapping)
        {
            IAstRefOrValue     convertedValue;
            ObjectsMapperDescr mapper = objectsMapperManager.GetMapperInt(
                mapping.Source.MemberType,
                mapping.Destination.MemberType,
                mappingConfigurator);
            int mapperId = AddObjectToStore(mapper);

            convertedValue = AstBuildHelper.CallMethod(
                typeof(ObjectsMapperBaseImpl).GetMethod(
                    "Map",
                    new Type[] { typeof(object), typeof(object), typeof(object) }
                    ),

                new AstReadFieldRef
            {
                fieldInfo    = typeof(ObjectsMapperDescr).GetField("mapper"),
                sourceObject = GetStoredObject(mapperId, mapper.GetType())
            },

                new List <IAstStackItem>()
            {
                AstBuildHelper.ReadMembersChain(
                    AstBuildHelper.ReadLocalRA(locFrom),
                    mapping.Source.MembersChain
                    ),
                AstBuildHelper.ReadMembersChain(
                    AstBuildHelper.ReadLocalRA(locTo),
                    mapping.Destination.MembersChain
                    ),
                (IAstRef)AstBuildHelper.ReadLocalRA(locState)
            }
                );
            return(convertedValue);
        }