Optimising string-to-enum mapping

Author: SteveWilkes

AgileMapper.UnitTests/SimpleTypeConversion/WhenConvertingToEnums.cs

@@ -141,6 +141,26 @@ public void ShouldMapANonMatchingStringToANullableEnum()
             result.Value.ShouldBeNull();
         }
 
+        [Fact]
+        public void ShouldMapANullStringOverANullableEnum()
+        {
+            var source = new PublicField<string> { Value = default(string) };
+            var target = new PublicProperty<Title?> { Value = Dr };
+
+            Mapper.Map(source).Over(target);
+
+            target.Value.ShouldBeDefault();
+        }
+
+        [Fact]
+        public void ShouldMapAnEmptyStringOnToAnEnum()
+        {
+            var source = new PublicField<string> { Value = string.Empty };
+            var result = Mapper.Map(source).OnTo(new PublicProperty<Title>());
+
+            result.Value.ShouldBeDefault();
+        }
+
         [Fact]
         public void ShouldMapAnEnumToAnEnum()
         {

AgileMapper/DataSources/DataSourceBase.cs

@@ -14,11 +14,11 @@ protected DataSourceBase(IQualifiedMember sourceMember, Expression value)
         {
         }
 
-        protected DataSourceBase(IDataSource wrappedDataSource, Expression value = null)
+        protected DataSourceBase(IDataSource wrappedDataSource, Expression value)
             : this(
                   wrappedDataSource.SourceMember,
                   wrappedDataSource.Variables,
-                  value ?? wrappedDataSource.Value,
+                  value,
                   wrappedDataSource.Condition)
         {
         }

AgileMapper/ObjectPopulation/ObjectMapper.cs

@@ -46,6 +46,8 @@ public ObjectMapper(
             }
         }
 
+        #region Setup
+
         private ICache<ObjectMapperKeyBase, IRecursionMapperFunc> CreateRecursionMapperFuncs()
         {
             var cache = MapperData.MapperContext.Cache.CreateNew<ObjectMapperKeyBase, IRecursionMapperFunc>();
@@ -80,8 +82,6 @@ private ICache<ObjectMapperKeyBase, IRecursionMapperFunc> CreateRecursionMapperF
             return cache;
         }
 
-        #region Setup
-
         #endregion
 
         public LambdaExpression MappingLambda { get; }

AgileMapper/TypeConversion/ToEnumConverter.cs

@@ -70,7 +70,6 @@ public override Expression GetConversion(Expression sourceValue, Type targetEnum
             return GetStringValueConversion(
                 sourceValue,
                 fallbackValue,
-                nonNullableSourceType,
                 nonNullableTargetEnumType);
         }
 
@@ -85,7 +84,7 @@ private Expression GetFlagsEnumConversion(
 
             var enumValueVariable = Expression.Variable(underlyingEnumType, enumTypeName + "Value");
             var underlyingTypeDefault = underlyingEnumType.ToDefaultExpression();
-            var assignEnumValue = Expression.Assign(enumValueVariable, underlyingTypeDefault);
+            var assignEnumValue = enumValueVariable.AssignTo(underlyingTypeDefault);
 
             if (nonNullableSourceType.IsNumeric())
             {
@@ -118,13 +117,14 @@ private Expression GetFlagsEnumConversion(
             var enumeratorCurrent = Expression.Property(sourceValuesVariable, "Current");
             var stringTrimMethod = typeof(string).GetPublicInstanceMethod("Trim", parameterCount: 0);
             var currentTrimmed = Expression.Call(enumeratorCurrent, stringTrimMethod);
-            var assignLocalVariable = Expression.Assign(localSourceValueVariable, currentTrimmed);
+            var assignLocalVariable = localSourceValueVariable.AssignTo(currentTrimmed);
 
-            var numericTryParseCall = GetNumericTryParseCall(
-                enumTypeName,
-                underlyingEnumType,
-                localSourceValueVariable,
-                out var sourceNumericValueVariable);
+            var isNumericTest = GetIsNumericTest(localSourceValueVariable);
+
+            var sourceNumericValueVariableName = enumTypeName + underlyingEnumType.Name + "Value";
+            var sourceNumericValueVariable = Expression.Variable(underlyingEnumType, sourceNumericValueVariableName);
+            var parsedString = GetStringParseCall(localSourceValueVariable, underlyingEnumType);
+            var assignNumericVariable = sourceNumericValueVariable.AssignTo(parsedString);
 
             var numericValuePopulationLoop = GetNumericToFlagsEnumPopulationLoop(
                 nonNullableTargetEnumType,
@@ -136,6 +136,7 @@ private Expression GetFlagsEnumConversion(
 
             var numericValuePopulationBlock = Expression.Block(
                 new[] { enumValuesVariable },
+                assignNumericVariable,
                 assignEnumValues,
                 numericValuePopulationLoop);
 
@@ -147,7 +148,7 @@ private Expression GetFlagsEnumConversion(
             var assignParsedEnumValue = Expression.OrAssign(enumValueVariable, stringValueConversion);
 
             var assignValidValuesIfPossible = Expression.IfThenElse(
-                numericTryParseCall,
+                isNumericTest,
                 numericValuePopulationBlock,
                 assignParsedEnumValue);
 
@@ -187,7 +188,7 @@ private static Expression GetNumericToFlagsEnumConversion(
                 sourceValue = Expression.Convert(sourceValue, underlyingEnumType);
             }
 
-            var assignSourceVariable = Expression.Assign(sourceValueVariable, sourceValue);
+            var assignSourceVariable = sourceValueVariable.AssignTo(sourceValue);
 
             var populationLoop = GetNumericToFlagsEnumPopulationLoop(
                 nonNullableTargetEnumType,
@@ -227,7 +228,7 @@ private static Expression GetNumericToFlagsEnumPopulationLoop(
 
             var localEnumValueVariable = Expression.Variable(underlyingEnumType, enumTypeName);
             var enumeratorCurrent = Expression.Property(enumValuesVariable, "Current");
-            var assignLocalVariable = Expression.Assign(localEnumValueVariable, enumeratorCurrent);
+            var assignLocalVariable = localEnumValueVariable.AssignTo(enumeratorCurrent);
 
             var localVariableAndSourceValue = Expression.And(localEnumValueVariable, sourceValueVariable);
             var andResultEqualsEnumValue = Expression.Equal(localVariableAndSourceValue, localEnumValueVariable);
@@ -298,21 +299,19 @@ private static Expression GetLoopExitCheck(
             return Expression.IfThen(Expression.Not(enumeratorMoveNext), Expression.Break(loopBreakTarget));
         }
 
-        private static Expression GetNumericTryParseCall(
-            string enumTypeName,
-            Type underlyingEnumType,
-            Expression stringValue,
-            out ParameterExpression numericValueVariable)
+        private static Expression GetIsNumericTest(Expression stringValue)
         {
-            var tryParseMethod = underlyingEnumType
-                .GetPublicStaticMethod("TryParse", parameterCount: 2);
-
-            var sourceNumericValueVariableName = enumTypeName + underlyingEnumType.Name + "Value";
-            numericValueVariable = Expression.Parameter(underlyingEnumType, sourceNumericValueVariableName);
-
-            var tryParseCall = Expression.Call(tryParseMethod, stringValue, numericValueVariable);
+            return Expression.Call(
+                typeof(char).GetPublicStaticMethod("IsDigit", typeof(string), typeof(int)),
+                stringValue,
+                0.ToConstantExpression());
+        }
 
-            return tryParseCall;
+        public static Expression GetStringParseCall(Expression sourceValue, Type underlyingEnumType)
+        {
+            return Expression.Call(
+                underlyingEnumType.GetPublicStaticMethod("Parse", typeof(string)),
+                sourceValue);
         }
 
         private static Expression GetStringToEnumConversion(
@@ -449,9 +448,16 @@ private static Expression GetNumericToEnumConversion(
             return nonNullValidValueOrFallback;
         }
 
-        private static Expression GetIsValidEnumValueCheck(Type enumType, Expression value)
+        private static Expression GetIsValidEnumValueCheck(
+            Type enumType,
+            Expression value,
+            Expression validEnumValues = null)
         {
-            var validEnumValues = GetEnumValuesConstant(enumType, value.Type);
+            if (validEnumValues == null)
+            {
+                validEnumValues = GetEnumValuesConstant(enumType, value.Type);
+            }
+
             var containsMethod = validEnumValues.Type.GetPublicInstanceMethod("Contains");
             var containsCall = Expression.Call(validEnumValues, containsMethod, value);
 
@@ -461,7 +467,6 @@ private static Expression GetIsValidEnumValueCheck(Type enumType, Expression val
         private Expression GetStringValueConversion(
             Expression sourceValue,
             Expression fallbackValue,
-            Type nonNullableSourceType,
             Type nonNullableTargetEnumType)
         {
             if (sourceValue.Type != typeof(string))
@@ -471,29 +476,57 @@ private Expression GetStringValueConversion(
 
             var underlyingEnumType = Enum.GetUnderlyingType(nonNullableTargetEnumType);
 
-            var nameMatchingConversion = GetStringToEnumConversion(
+            var isNumericTest = GetIsNumericTest(sourceValue);
+
+            var numericConversion = GetNumericStringToEnumConversion(
                 sourceValue,
                 fallbackValue,
-                nonNullableTargetEnumType);
+                nonNullableTargetEnumType,
+                underlyingEnumType);
 
-            var tryParseCall = GetNumericTryParseCall(
-                GetVariableNameFor(nonNullableTargetEnumType),
-                underlyingEnumType,
+            var nameMatchingConversion = GetStringToEnumConversion(
                 sourceValue,
-                out var parseResultVariable);
-
-            var numericConversion = GetNumericToEnumConversion(
-                parseResultVariable,
                 fallbackValue,
-                nonNullableSourceType,
                 nonNullableTargetEnumType);
 
             var numericOrNameConversion = Expression.Condition(
-                tryParseCall,
+                isNumericTest,
                 numericConversion,
                 nameMatchingConversion);
 
-            return Expression.Block(new[] { parseResultVariable }, numericOrNameConversion);
+            var valueIsNullOrEmpty = Expression.Call(
+                typeof(string).GetPublicStaticMethod("IsNullOrWhiteSpace"),
+                sourceValue);
+
+            var convertedValueOrDefault = Expression.Condition(
+                valueIsNullOrEmpty,
+                fallbackValue,
+                numericOrNameConversion);
+
+            return convertedValueOrDefault;
+        }
+
+        private static Expression GetNumericStringToEnumConversion(
+            Expression sourceValue,
+            Expression fallbackValue,
+            Type nonNullableTargetEnumType,
+            Type underlyingEnumType)
+        {
+            var validEnumValues = Enum
+                .GetValues(nonNullableTargetEnumType)
+                .Cast<object>()
+                .Select(v => Convert.ChangeType(v, underlyingEnumType).ToString())
+                .ToArray()
+                .ToConstantExpression(typeof(ICollection<string>));
+
+            var parsedString = GetStringParseCall(sourceValue, underlyingEnumType);
+
+            var validValueOrFallback = Expression.Condition(
+                GetIsValidEnumValueCheck(nonNullableTargetEnumType, sourceValue, validEnumValues),
+                parsedString.GetConversionTo(fallbackValue.Type),
+                fallbackValue);
+
+            return validValueOrFallback;
         }
     }
 }