Merge pull request #2933 from AutoMapper/type-map-attributes

Attributes to define a type map configuration

Author: jbogard

src/AutoMapper/AutoMapAttribute.cs

@@ -0,0 +1,26 @@
+using System;
+
+namespace AutoMapper
+{
+    /// <summary>
+    /// Auto map to this destination type from the specified source type.
+    /// Discovered during scanning assembly scanning for configuration when calling <see cref="O:AutoMapper.IMapperConfigurationExpression.AddMaps"/>
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface)]
+    public sealed class AutoMapAttribute : Attribute
+    {
+        public AutoMapAttribute(Type sourceType) 
+            => SourceType = sourceType;
+
+        public Type SourceType { get; }
+        public bool ReverseMap { get; set; }
+
+        public void ApplyConfiguration(IMappingExpression mappingExpression)
+        {
+            if (ReverseMap)
+            {
+                mappingExpression.ReverseMap();
+            }
+        }
+    }
+}

src/AutoMapper/Configuration/CtorParamConfigurationExpression.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+
+namespace AutoMapper.Configuration
+{
+    public class CtorParamConfigurationExpression<TSource> : ICtorParamConfigurationExpression<TSource>, ICtorParameterConfiguration
+    {
+        private readonly string _ctorParamName;
+        private readonly List<Action<ConstructorParameterMap>> _ctorParamActions = new List<Action<ConstructorParameterMap>>();
+
+        public CtorParamConfigurationExpression(string ctorParamName) => _ctorParamName = ctorParamName;
+
+        public void MapFrom<TMember>(Expression<Func<TSource, TMember>> sourceMember)
+        {
+            _ctorParamActions.Add(cpm => cpm.CustomMapExpression = sourceMember);
+        }
+
+        public void MapFrom<TMember>(Func<TSource, ResolutionContext, TMember> resolver)
+        {
+            Expression<Func<TSource, ResolutionContext, TMember>> resolverExpression = (src, ctxt) => resolver(src, ctxt);
+            _ctorParamActions.Add(cpm => cpm.CustomMapFunction = resolverExpression);
+        }
+
+        public void Configure(TypeMap typeMap)
+        {
+            var ctorParams = typeMap.ConstructorMap?.CtorParams;
+            if (ctorParams == null)
+            {
+                throw new AutoMapperConfigurationException($"The type {typeMap.Types.DestinationType.Name} does not have a constructor.\n{typeMap.Types.DestinationType.FullName}");
+            }
+
+            var parameter = ctorParams.SingleOrDefault(p => p.Parameter.Name == _ctorParamName);
+            if (parameter == null)
+            {
+                throw new AutoMapperConfigurationException($"{typeMap.Types.DestinationType.Name} does not have a constructor with a parameter named '{_ctorParamName}'.\n{typeMap.Types.DestinationType.FullName}");
+            }
+            parameter.CanResolveValue = true;
+
+            foreach (var action in _ctorParamActions)
+            {
+                action(parameter);
+            }
+        }
+    }
+}

src/AutoMapper/Configuration/ICtorParameterConfiguration.cs

@@ -0,0 +1,7 @@
+namespace AutoMapper.Configuration
+{
+    public interface ICtorParameterConfiguration
+    {
+        void Configure(TypeMap typeMap);
+    }
+}

src/AutoMapper/Configuration/ISourceMemberConfiguration.cs

@@ -0,0 +1,7 @@
+namespace AutoMapper.Configuration
+{
+    public interface ISourceMemberConfiguration
+    {
+        void Configure(TypeMap typeMap);
+    }
+}

src/AutoMapper/Configuration/MapperConfigurationExpression.cs

@@ -29,6 +29,10 @@ public void CreateProfile(string profileName, Action<IProfileExpression> config)
 
         private class NamedProfile : Profile
         {
+            public NamedProfile(string profileName) : base(profileName)
+            {
+            }
+
             public NamedProfile(string profileName, Action<IProfileExpression> config) : base(profileName, config)
             {
             }
@@ -44,41 +48,62 @@ public void AddProfile(Profile profile)
         public void AddProfile(Type profileType) => AddProfile((Profile)Activator.CreateInstance(profileType));
 
         public void AddProfiles(IEnumerable<Assembly> assembliesToScan)
-            => AddProfilesCore(assembliesToScan);
+            => AddMaps(assembliesToScan);
 
         public void AddProfiles(params Assembly[] assembliesToScan)
-            => AddProfilesCore(assembliesToScan);
+            => AddMaps(assembliesToScan);
 
         public void AddProfiles(IEnumerable<string> assemblyNamesToScan)
-            => AddProfilesCore(assemblyNamesToScan.Select(name => Assembly.Load(new AssemblyName(name))));
+            => AddMaps(assemblyNamesToScan.Select(name => Assembly.Load(new AssemblyName(name))));
 
         public void AddProfiles(params string[] assemblyNamesToScan)
-            => AddProfilesCore(assemblyNamesToScan.Select(name => Assembly.Load(new AssemblyName(name))));
+            => AddMaps(assemblyNamesToScan.Select(name => Assembly.Load(new AssemblyName(name))));
 
         public void AddProfiles(IEnumerable<Type> typesFromAssembliesContainingProfiles)
-            => AddProfilesCore(typesFromAssembliesContainingProfiles.Select(t => t.GetTypeInfo().Assembly));
+            => AddMaps(typesFromAssembliesContainingProfiles.Select(t => t.GetTypeInfo().Assembly));
 
         public void AddProfiles(params Type[] typesFromAssembliesContainingProfiles)
-            => AddProfilesCore(typesFromAssembliesContainingProfiles.Select(t => t.GetTypeInfo().Assembly));
+            => AddMaps(typesFromAssembliesContainingProfiles.Select(t => t.GetTypeInfo().Assembly));
+
+        public void AddMaps(IEnumerable<Assembly> assembliesToScan)
+            => AddMapsCore(assembliesToScan);
+
+        public void AddMaps(params Assembly[] assembliesToScan)
+            => AddMapsCore(assembliesToScan);
+
+        public void AddMaps(IEnumerable<string> assemblyNamesToScan)
+            => AddMapsCore(assemblyNamesToScan.Select(name => Assembly.Load(new AssemblyName(name))));
 
-        private void AddProfilesCore(IEnumerable<Assembly> assembliesToScan)
+        public void AddMaps(params string[] assemblyNamesToScan)
+            => AddMapsCore(assemblyNamesToScan.Select(name => Assembly.Load(new AssemblyName(name))));
+
+        public void AddMaps(IEnumerable<Type> typesFromAssembliesContainingMappingDefinitions)
+            => AddMapsCore(typesFromAssembliesContainingMappingDefinitions.Select(t => t.GetTypeInfo().Assembly));
+
+        public void AddMaps(params Type[] typesFromAssembliesContainingMappingDefinitions)
+            => AddMapsCore(typesFromAssembliesContainingMappingDefinitions.Select(t => t.GetTypeInfo().Assembly));
+
+        private void AddMapsCore(IEnumerable<Assembly> assembliesToScan)
         {
             var allTypes = assembliesToScan.Where(a => !a.IsDynamic).SelectMany(a => a.GetDefinedTypes()).ToArray();
+            var autoMapAttributeProfile = new NamedProfile(nameof(AutoMapAttribute));
 
-            var profiles =
-                allTypes
-                    .Where(t => typeof(Profile).GetTypeInfo().IsAssignableFrom(t))
-                    .Where(t => !t.IsAbstract)
-                    .Select(t => t.AsType());
-
-            foreach (var profile in profiles)
+            foreach (var type in allTypes)
             {
-                AddProfile(profile);
+                if (typeof(Profile).IsAssignableFrom(type) && !type.IsAbstract)
+                {
+                    AddProfile(type.AsType());
+                }
+                foreach (var autoMapAttribute in type.GetCustomAttributes<AutoMapAttribute>())
+                {
+                    var mappingExpression = autoMapAttributeProfile.CreateMap(autoMapAttribute.SourceType, type);
+                    autoMapAttribute.ApplyConfiguration(mappingExpression);
+                }
             }
 
+            AddProfile(autoMapAttributeProfile);
         }
 
-
         public void ConstructServicesUsing(Func<Type, object> constructor) => ServiceCtor = constructor;
     }
 }