use Enum.Parse<TEnum>

Author: lbargaoanu

src/AutoMapper/Mappers/StringToEnumMapper.cs

@@ -9,29 +9,36 @@ namespace AutoMapper.Internal.Mappers
     using static Expression;
     public class StringToEnumMapper : IObjectMapper
     {
-        private static readonly MethodInfo EqualsMethod = typeof(StringToEnumMapper).GetMethod("StringCompareOrdinalIgnoreCase");
-        private static readonly MethodInfo ParseMethod = typeof(Enum).GetMethod("Parse", new[] { typeof(Type), typeof(string), typeof(bool) });
-        private static readonly MethodInfo IsNullOrEmptyMethod = typeof(string).GetMethod("IsNullOrEmpty");
+        private static readonly MethodInfo EqualsMethod = typeof(StringToEnumMapper).GetMethod(nameof(StringCompareOrdinalIgnoreCase));
+        private static readonly MethodInfo ParseMethod = typeof(Enum).StaticGenericMethod("Parse", parametersCount: 2);
+        private static readonly PropertyInfo Length = typeof(string).GetProperty("Length");
         public bool IsMatch(TypePair context) => context.SourceType == typeof(string) && context.DestinationType.IsEnum;
         public Expression MapExpression(IGlobalConfiguration configurationProvider, ProfileMap profileMap,
             MemberMap memberMap, Expression sourceExpression, Expression destExpression)
         {
             var destinationType = destExpression.Type;
+            var ignoreCase = True;
+            var enumParse = Call(ParseMethod.MakeGenericMethod(destinationType), sourceExpression, ignoreCase);
+            var enumMember = CheckEnumMember(sourceExpression, destinationType, enumParse, EqualsMethod);
+            return Condition(Equal(Property(sourceExpression, Length), Zero), Default(destinationType), enumMember);
+        }
+        internal static Expression CheckEnumMember(Expression sourceExpression, Type enumType, Expression defaultExpression, MethodInfo comparison = null)
+        {
             List<SwitchCase> switchCases = null;
-            foreach (var memberInfo in destinationType.GetFields(TypeExtensions.StaticFlags))
+            foreach (var memberInfo in enumType.GetFields(TypeExtensions.StaticFlags))
             {
                 var attributeValue = memberInfo.GetCustomAttribute<EnumMemberAttribute>()?.Value;
-                if (attributeValue != null)
+                if (attributeValue == null)
                 {
-                    var switchCase = SwitchCase(
-                        ToType(Constant(Enum.ToObject(destinationType, memberInfo.GetValue(null))), destinationType), Constant(attributeValue));
-                    switchCases ??= new();
-                    switchCases.Add(switchCase);
+                    continue;
                 }
+                var enumToObject = Constant(Enum.ToObject(enumType, memberInfo.GetValue(null)));
+                var attributeConstant = Constant(attributeValue);
+                var (body, testValue) = comparison == null ? (attributeConstant, enumToObject) : (ToType(enumToObject, enumType), attributeConstant);
+                switchCases ??= new();
+                switchCases.Add(SwitchCase(body, testValue));
             }
-            var enumParse = ToType(Call(ParseMethod, Constant(destinationType), sourceExpression, True), destinationType);
-            var parse = switchCases != null ? Switch(sourceExpression, enumParse, EqualsMethod, switchCases) : enumParse;
-            return Condition(Call(IsNullOrEmptyMethod, sourceExpression), Default(destinationType), parse);
+            return switchCases == null ? defaultExpression : Switch(sourceExpression, defaultExpression, comparison, switchCases);
         }
         public static bool StringCompareOrdinalIgnoreCase(string x, string y) => StringComparer.OrdinalIgnoreCase.Equals(x, y);
     }

src/AutoMapper/Mappers/ToStringMapper.cs

@@ -1,9 +1,5 @@
 using AutoMapper.Execution;
-using System;
-using System.Collections.Generic;
 using System.Linq.Expressions;
-using System.Reflection;
-using System.Runtime.Serialization;
 namespace AutoMapper.Internal.Mappers
 {
     using static Expression;
@@ -13,23 +9,8 @@ public class ToStringMapper : IObjectMapper
         public Expression MapExpression(IGlobalConfiguration configurationProvider, ProfileMap profileMap, MemberMap memberMap, Expression sourceExpression, Expression destExpression)
         {
             var sourceType = sourceExpression.Type;
-            Expression toStringCall = Call(sourceExpression, ExpressionBuilder.ObjectToString);
-            return sourceType.IsEnum ? EnumToString(sourceExpression, sourceType, toStringCall) : toStringCall;
-        }
-        private static Expression EnumToString(Expression sourceExpression, Type sourceType, Expression toStringCall)
-        {
-            List<SwitchCase> switchCases = null;
-            foreach (var memberInfo in sourceType.GetFields(TypeExtensions.StaticFlags))
-            {
-                var attributeValue = memberInfo.GetCustomAttribute<EnumMemberAttribute>()?.Value;
-                if (attributeValue != null)
-                {
-                    var switchCase = SwitchCase(Constant(attributeValue), Constant(Enum.ToObject(sourceType, memberInfo.GetValue(null))));
-                    switchCases ??= new();
-                    switchCases.Add(switchCase);
-                }
-            }
-            return switchCases != null ? Switch(sourceExpression, toStringCall, null, switchCases) : toStringCall;
+            var toStringCall = Call(sourceExpression, ExpressionBuilder.ObjectToString);
+            return sourceType.IsEnum ? StringToEnumMapper.CheckEnumMember(sourceExpression, sourceType, toStringCall) : toStringCall;
         }
     }
 }

src/UnitTests/Enumerations.cs

@@ -6,6 +6,13 @@
 
 namespace AutoMapper.Tests
 {
+    public class InvalidStringToEnum : AutoMapperSpecBase
+    {
+        protected override MapperConfiguration CreateConfiguration() => new(_=> { });
+        [Fact]
+        public void Should_throw() => new Action(()=>Map<ConsoleColor>("d")).ShouldThrow<AutoMapperMappingException>().InnerException.Message.ShouldBe(
+            "Requested value 'd' was not found.");
+    }
     public class DefaultEnumValueToString : AutoMapperSpecBase
     {
         Destination _destination;