Example #1
0
        private void CreateAttributeBuilders()
        {
            foreach (var assembly in Config.AttributeAssemblies)
            {
                foreach (var type in assembly.GetTypes())
                {
                    var attribute = type.GetCustomAttributes(typeof(MapFromAttribute), false).FirstOrDefault();
                    if (attribute != null)
                    {
                        var sourceType = (attribute as MapFromAttribute).SourceType;

                        var key = new MappingKey(sourceType, type);
                        if (Config.Builders.ContainsKey(key))
                        {
                            throw new MappingAlreadyExistsException("Another mapping already exists with the supplied types");
                        }

                        var builder = CreateMappingBuilder(sourceType, type);

                        Config.Builders.Add(key, builder);

                        Config.BuilderDescriptors.Add(new BuilderDescriptor(builder.SourceType, builder.TargetType, builder.Dependencies, true));
                    }
                }
            }
        }
Example #2
0
        public void CreateMapping <TSource, TTarget>()
        {
            var key = new MappingKey(typeof(TSource), typeof(TTarget));

            if (Builders.ContainsKey(key))
            {
                throw new MappingAlreadyExistsException("Another mapping already exists with the supplied types");
            }

            var builder = new MappingBuilder <TSource, TTarget>(this);

            builder.CreateDefaultBindings();

            Builders.Add(key, builder);
            BuilderDescriptors.Add(new BuilderDescriptor(typeof(TSource), typeof(TTarget), builder.Dependencies, true));
        }
Example #3
0
        /// <summary>
        /// Creates a new mapper object using the registered mappings or the default mappings where necessary.
        /// </summary>
        /// <returns>Returns a new <see cref="IMapper"/> object that contains the mappings.</returns>
        public IMapper CreateMapper()
        {
            CreateAttributeBuilders();

            var comparer = EqualityComparer <BuilderDescriptor> .Default;

            // Check for circular dependency
            Config.BuilderDescriptors.TopologicalSort(b => b.Dependencies, comparer);

            var mappings = new Dictionary <MappingKey, IMapping>();

            // Create all non-user defined mappings
            CreateDefaultBuilders();

            foreach (var builderDescriptor in Config.BuilderDescriptors.TopologicalSort(b => b.Dependencies, comparer))
            {
                var key = new MappingKey(builderDescriptor.SourceType, builderDescriptor.TargetType);
                Config.Builders.TryGetValue(key, out var builder);

                var dependencies = mappings.Where(m => builder.Dependencies.Any(d => d.SourceType == m.Key.SourceType && d.TargetType == m.Key.TargetType)).ToDictionary(i => i.Key, i => i.Value);

                var mapping = builder.Build(dependencies);

                mappings.Add(key, mapping);
            }

            foreach (var parametrizedBuilder in Config.ParametrizedBuilders)
            {
                var dependencies = mappings.Where(m => parametrizedBuilder.Value.Builder.Dependencies.Any(d => d.SourceType == m.Key.SourceType && d.TargetType == m.Key.TargetType)).ToDictionary(i => i.Key, i => i.Value);

                // This just stores the dependencies for later use
                parametrizedBuilder.Value.Builder.Build(dependencies);

                mappings.Add(parametrizedBuilder.Key, parametrizedBuilder.Value.Mapping);
            }

            return(new Mapper
            {
                Mappings = mappings
            });
        }
Example #4
0
        public void CreateMapping <TSource, TTarget, TParam>(Action <IMappingBuilder <TSource, TTarget, TParam> > mappingFactory)
        {
            var key = new MappingKey(typeof(TSource), typeof(TTarget), typeof(TParam));

            if (ParametrizedBuilders.ContainsKey(key))
            {
                throw new MappingAlreadyExistsException("Another mapping already exists with the supplied types");
            }

            var builder = new MappingBuilder <TSource, TTarget, TParam>(this);

            mappingFactory(builder);
            builder.CreateDefaultBindings(); // Should be run after the explicit mappings

            ParametrizedBuilders.Add(key, new ParametrizedBuilderDescriptor
            {
                Mapping = new Mapping <TSource, TTarget, TParam> {
                    Builder = builder
                },
                Builder = builder
            });
        }