Map different enums by name

ExpressMapper NETCORE/ExpressMapper NETCORE.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <VersionPrefix>1.9.1.0</VersionPrefix>
+    <TargetFramework>netstandard1.6</TargetFramework>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <AssemblyName>ExpressMapper</AssemblyName>
+    <PackageId>ExpressMapper NETCORE</PackageId>
+    <NetStandardImplicitPackageVersion>1.6.0</NetStandardImplicitPackageVersion>
+    <PackageTargetFallback>$(PackageTargetFallback);dnxcore50</PackageTargetFallback>
+    <GenerateAssemblyTitleAttribute>false</GenerateAssemblyTitleAttribute>
+    <GenerateAssemblyDescriptionAttribute>false</GenerateAssemblyDescriptionAttribute>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+    <GenerateAssemblyCopyrightAttribute>false</GenerateAssemblyCopyrightAttribute>
+    <GenerateAssemblyVersionAttribute>false</GenerateAssemblyVersionAttribute>
+    <GenerateAssemblyFileVersionAttribute>false</GenerateAssemblyFileVersionAttribute>
+    <GenerateAssemblyInformationalVersionAttribute>false</GenerateAssemblyInformationalVersionAttribute>
+  </PropertyGroup>
+
+  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard1.6' ">
+    <PackageReference Include="System.Linq.Expressions" Version="4.1.0" />
+    <PackageReference Include="Microsoft.CSharp" Version="4.0.1" />
+    <PackageReference Include="System.Linq.Queryable" Version="4.0.1" />
+    <PackageReference Include="System.Globalization.Extensions" Version="4.0.1" />
+  </ItemGroup>
+
+</Project>

ExpressMapper NETCORE/IMappingServiceProvider.cs

@@ -27,5 +27,6 @@ public interface IMappingServiceProvider
         Dictionary<int, IList<long>> CustomMappingsBySource { get; }
         IQueryable<TN> Project<T, TN>(IQueryable<T> source);
         bool CaseSensetiveMemberMap { get; set; }
+        bool MapEnumsByName { get; set; }
     }
 }

ExpressMapper NETCORE/Mapper.cs

@@ -93,5 +93,10 @@ public static void MemberCaseSensitiveMap(bool caseSensitive)
         {
             Instance.CaseSensetiveMemberMap = caseSensitive;
         }
+
+        public static void MapEnumsByName()
+        {
+            Instance.MapEnumsByName = true;
+        }
     }
 }

ExpressMapper NETCORE/MappingServiceBase.cs

@@ -168,7 +168,7 @@ public Expression GetMemberMappingExpression(Expression left, Expression right,
 
                 if (destType.GetInfo().IsEnum && sourceType.GetInfo().IsEnum)
                 {
-                    return Expression.Assign(left, Expression.Convert(Expression.Convert(right, _enumImplicitConversionType), destType));
+                    return GetEnumMappingExpression(left, right, sourceType, destType);
                 }
 
                 if (typeof(IConvertible).GetInfo().IsAssignableFrom(destType) &&
@@ -201,6 +201,30 @@ public Expression GetMemberMappingExpression(Expression left, Expression right,
             return conditionalExpression;
         }
 
+        private Expression GetEnumMappingExpression(Expression left, Expression right, Type sourceType, Type destType)
+        {
+            if (!MappingServiceProvider.MapEnumsByName)
+            {
+                return Expression.Assign(left, Expression.Convert(Expression.Convert(right, _enumImplicitConversionType), destType));
+            }
+
+            var getNameTypeParam = Expression.Parameter(typeof(Type));
+            var getNameObjectParam = Expression.Parameter(typeof(object));
+            var getNameCall = Expression.Call(typeof(Enum), nameof(Enum.GetName), null, getNameTypeParam, getNameObjectParam);
+            var getNameLambda = Expression.Lambda(getNameCall, getNameTypeParam, getNameObjectParam);
+
+            var parseTypeParam = Expression.Parameter(typeof(Type));
+            var parseStringParam = Expression.Parameter(typeof(string));
+            var parseCall = Expression.Call(typeof(Enum), nameof(Enum.Parse), null, parseTypeParam, parseStringParam);
+            var parseLambda = Expression.Lambda(parseCall, parseTypeParam, parseStringParam);
+
+            var rightAsObject = Expression.Convert(right, typeof(object));
+            var getNameInvoke = Expression.Invoke(getNameLambda, Expression.Constant(sourceType), rightAsObject);
+            var parseInvoke = Expression.Invoke(parseLambda, Expression.Constant(destType), getNameInvoke);
+
+            return Expression.Assign(left, Expression.Convert(parseInvoke, destType));
+        }
+
         private static Expression CreateAssignExpression(Expression setMethod, Expression getMethod, Type setType, Type setNullableType, Type getNullableType)
         {
             var left = setMethod;

ExpressMapper NETCORE/MappingServiceProvider.cs

@@ -59,6 +59,7 @@ public IQueryable<TN> Project<T, TN>(IQueryable<T> source)
         }
 
         public bool CaseSensetiveMemberMap { get; set; }
+        public bool MapEnumsByName { get; set; }
 
         public IMemberConfiguration<T, TN> Register<T, TN>()
         {
@@ -225,6 +226,7 @@ public void Reset()
                     mappingService.Reset();
                 }
                 CaseSensetiveMemberMap = false;
+                MapEnumsByName = false;
             }
         }