Using Type's to-string operators to convert values to strings where available, fixes issue #51 / Simplifying type converter hierarchy

Author: SteveWilkes

AgileMapper.UnitTests/Dictionaries/WhenMappingFromDictionariesToNewEnumerableMembers.cs

@@ -118,32 +118,45 @@ public void ShouldMapToAComplexTypeArrayFromUntypedDottedEntries()
 #if !NET_STANDARD
 
         // See https://github.com/agileobjects/AgileMapper/issues/50
+        // See https://github.com/agileobjects/AgileMapper/issues/51
         [Fact]
         public void ShouldMapStringValuesToAStringArray()
         {
             var source = new Dictionary<string, StringValues>
             {
-                ["WidgetId"] = new StringValues("123"),
-                ["ClientId"] = new StringValues("456"),
-                ["TestPayload"] = new StringValues(new[] { "a", "b", "c" })
+                ["StringValue"] = new StringValues("123"),
+                ["StringArray"] = new StringValues(new[] { "a", "b", "c" }),
+                ["IntValue"] = new StringValues("456"),
+                ["IntArray"] = new StringValues(new[] { "5", "4", "3" }),
+                ["DoubleValue"] = new StringValues("35.4354"),
+                ["DoubleArray"] = new StringValues(new[] { "1.23", "2.23", "3.23", "4.23" })
             };
 
             var result = Mapper.Map(source).ToANew<StringValuesTestDto>();
 
-            result.WidgetId.ShouldBe("123");
-            result.ClientId.ShouldBe("456");
-            result.TestPayload.ShouldBe("a", "b", "c");
+            result.StringValue.ShouldBe("123");
+            result.StringArray.ShouldBe("a", "b", "c");
+            result.IntValue.ShouldBe(456);
+            result.IntArray.ShouldBe(5, 4, 3);
+            result.DoubleValue.ShouldBe(35.4354);
+            result.DoubleArray.ShouldBe(1.23, 2.23, 3.23, 4.23);
         }
 
         #region Helper Class
 
         public class StringValuesTestDto
         {
-            public string WidgetId { get; set; }
+            public string StringValue { get; set; }
 
-            public string ClientId { get; set; }
+            public string[] StringArray { get; set; }
 
-            public string[] TestPayload { get; set; }
+            public int IntValue { get; set; }
+
+            public int[] IntArray { get; set; }
+
+            public double DoubleValue { get; set; }
+
+            public double[] DoubleArray { get; set; }
         }
 
         #endregion

AgileMapper/TypeConversion/ConverterSet.cs

@@ -23,8 +23,8 @@ public ConverterSet()
                 new ToNumericConverter<int>(toStringConverter),
                 new ToBoolConverter(toStringConverter),
                 new ToEnumConverter(toStringConverter),
-                new DefaultTryParseConverter<DateTime>(toStringConverter),
-                new DefaultTryParseConverter<Guid>(toStringConverter),
+                new TryParseConverter<DateTime>(toStringConverter),
+                new TryParseConverter<Guid>(toStringConverter),
                 new ToNumericConverter<decimal>(toStringConverter),
                 new ToNumericConverter<double>(toStringConverter),
                 new ToNumericConverter<long>(toStringConverter),

AgileMapper/TypeConversion/DefaultTryParseConverter.cs

@@ -2,20 +2,105 @@
 {
     using System;
     using System.Linq;
+    using System.Linq.Expressions;
     using Extensions.Internal;
+    using NetStandardPolyfills;
 
-    internal class ToNumericConverter<TNumeric> : ToNumericConverterBase
+    internal class ToNumericConverter<TNumeric> : TryParseConverter<TNumeric>
     {
         private static readonly Type[] _coercibleNumericTypes =
             typeof(TNumeric)
                 .GetCoercibleNumericTypes()
                 .ToArray();
 
         public ToNumericConverter(ToStringConverter toStringConverter)
-            : base(toStringConverter, typeof(TNumeric))
+            : base(toStringConverter)
         {
         }
 
-        protected override bool IsCoercible(Type sourceType) => _coercibleNumericTypes.Contains(sourceType);
+        protected override bool CanConvert(Type nonNullableSourceType)
+        {
+            return base.CanConvert(nonNullableSourceType) ||
+                   nonNullableSourceType.IsEnum() ||
+                  (nonNullableSourceType == typeof(char)) ||
+                   Constants.NumericTypes.Contains(nonNullableSourceType);
+        }
+
+        public override Expression GetConversion(Expression sourceValue, Type targetType)
+        {
+            var sourceType = GetNonEnumSourceType(sourceValue);
+
+            if (IsCoercible(sourceType))
+            {
+                if (!targetType.IsWholeNumberNumeric())
+                {
+                    sourceValue = sourceValue.GetConversionTo(sourceType);
+                }
+
+                return sourceValue.GetConversionTo(targetType);
+            }
+
+            return IsNumericType(sourceType)
+                ? GetCheckedNumericConversion(sourceValue, targetType)
+                : base.GetConversion(sourceValue, targetType);
+        }
+
+        private static Type GetNonEnumSourceType(Expression sourceValue)
+            => sourceValue.Type.IsEnum() ? Enum.GetUnderlyingType(sourceValue.Type) : sourceValue.Type;
+
+        private static bool IsNumericType(Type type)
+        {
+            if ((type == typeof(string)) ||
+                (type == typeof(object)) ||
+                (type == typeof(char)) ||
+                (type == typeof(char?)))
+            {
+                return false;
+            }
+
+            return Constants.NumericTypes.Contains(type);
+        }
+
+        private static bool IsCoercible(Type sourceType) => _coercibleNumericTypes.Contains(sourceType);
+
+        private static Expression GetCheckedNumericConversion(Expression sourceValue, Type targetType)
+        {
+            var castSourceValue = sourceValue.GetConversionTo(targetType);
+
+            if (sourceValue.Type.GetNonNullableType() == targetType.GetNonNullableType())
+            {
+                return castSourceValue;
+            }
+
+            var numericValueIsValid = GetNumericValueValidityCheck(sourceValue, targetType);
+            var defaultTargetType = targetType.ToDefaultExpression();
+            var inRangeValueOrDefault = Expression.Condition(numericValueIsValid, castSourceValue, defaultTargetType);
+
+            return inRangeValueOrDefault;
+        }
+
+        private static Expression GetNumericValueValidityCheck(Expression sourceValue, Type targetType)
+        {
+            var nonNullableTargetType = targetType.GetNonNullableType();
+            var numericValueIsInRange = NumericValueIsInRangeComparison.For(sourceValue, nonNullableTargetType);
+
+            if (NonWholeNumberCheckIsNotRequired(sourceValue, nonNullableTargetType))
+            {
+                return numericValueIsInRange;
+            }
+
+            var moduloOneEqualsZero = NumericConversions.GetModuloOneIsZeroCheck(sourceValue);
+
+            return Expression.AndAlso(numericValueIsInRange, moduloOneEqualsZero);
+        }
+
+        private static bool NonWholeNumberCheckIsNotRequired(Expression sourceValue, Type nonNullableTargetType)
+        {
+            var sourceType = sourceValue.Type.GetNonNullableType();
+
+            return sourceType.IsEnum() ||
+                   sourceType.IsWholeNumberNumeric() ||
+                  !nonNullableTargetType.IsWholeNumberNumeric();
+        }
     }
 }

AgileMapper/TypeConversion/ToNumericConverter.cs

@@ -32,6 +32,11 @@ public Expression GetConversion(Expression sourceValue)
                 return GetDateTimeToStringConversion(sourceValue, nonNullableSourceType);
             }
 
+            if (HasToStringOperator(nonNullableSourceType, out var operatorMethod))
+            {
+                return Expression.Call(operatorMethod, sourceValue);
+            }
+
             var toStringMethod = sourceValue.Type
                 .GetPublicInstanceMethod("ToString", parameterCount: 0);
 
@@ -40,6 +45,19 @@ public Expression GetConversion(Expression sourceValue)
             return toStringCall;
         }
 
+        public bool HasToStringOperator(Type nonNullableSourceType, out MethodInfo operatorMethod)
+        {
+            operatorMethod = nonNullableSourceType
+                .GetPublicStaticMembers()
+                .Where(m => (m.Name == "op_Implicit") || (m.Name == "op_Explicit"))
+                .Cast<MethodInfo>()
+                .FirstOrDefault(m =>
+                    (m.ReturnType == typeof(string)) &&
+                    (m.GetParameters()[0].ParameterType == nonNullableSourceType));
+
+            return operatorMethod != null;
+        }
+
         #region Byte[] Conversion
 
         private static readonly MethodInfo _toBase64String = typeof(Convert)

AgileMapper/TypeConversion/ToNumericConverterBase.cs

@@ -6,35 +6,38 @@ namespace AgileObjects.AgileMapper.TypeConversion
     using Extensions.Internal;
     using NetStandardPolyfills;
 
-    internal abstract class TryParseConverterBase : ValueConverterBase
+    internal class TryParseConverter<T> : ValueConverterBase
     {
         private readonly ToStringConverter _toStringConverter;
         private readonly Type _nonNullableTargetType;
         private readonly Type _nullableTargetType;
         private readonly MethodInfo _tryParseMethod;
         private readonly ParameterExpression _valueVariable;
 
-        protected TryParseConverterBase(
-            ToStringConverter toStringConverter,
-            Type nonNullableTargetType)
+        public TryParseConverter(ToStringConverter toStringConverter)
         {
             _toStringConverter = toStringConverter;
-            _nonNullableTargetType = nonNullableTargetType;
-            _nullableTargetType = typeof(Nullable<>).MakeGenericType(nonNullableTargetType);
+            _nonNullableTargetType = typeof(T);
+            _nullableTargetType = typeof(Nullable<>).MakeGenericType(_nonNullableTargetType);
 
-            _tryParseMethod = nonNullableTargetType
+            _tryParseMethod = _nonNullableTargetType
                 .GetPublicStaticMethod("TryParse", parameterCount: 2);
 
             _valueVariable = Expression.Variable(
-                nonNullableTargetType,
-                nonNullableTargetType.GetVariableNameInCamelCase() + "Value");
+                _nonNullableTargetType,
+                _nonNullableTargetType.GetVariableNameInCamelCase() + "Value");
         }
 
         public override bool CanConvert(Type nonNullableSourceType, Type nonNullableTargetType)
             => nonNullableTargetType == _nonNullableTargetType && CanConvert(nonNullableSourceType);
 
         protected virtual bool CanConvert(Type nonNullableSourceType)
-            => (nonNullableSourceType == _nonNullableTargetType) || (nonNullableSourceType == typeof(object));
+        {
+            return (nonNullableSourceType == _nonNullableTargetType) ||
+                   (nonNullableSourceType == typeof(string)) ||
+                   (nonNullableSourceType == typeof(object)) ||
+                   _toStringConverter.HasToStringOperator(nonNullableSourceType, out var _);
+        }
 
         public override Expression GetConversion(Expression sourceValue, Type targetType)
         {