Merge pull request #400 from VictorSuzdalev/master

Fix an issue with nullable Enum to Enum conversion

Author: mythz

src/ServiceStack.Text/AutoMappingUtils.cs

@@ -27,7 +27,7 @@ public static T ConvertTo<T>(this object from)
 
             if (from.GetType().IsValueType())
             {
-                return (T)Convert.ChangeType(from, typeof(T), provider:null);
+                return (T)Convert.ChangeType(from, typeof(T), provider: null);
             }
 
             if (typeof(IEnumerable).IsAssignableFromType(typeof(T)))
@@ -699,7 +699,7 @@ public static PropertyGetterDelegate CreateTypeConverter(Type fromType, Type toT
             {
                 if (toType.IsEnum() && fromType.IsEnum())
                 {
-                    return fromValue => Enum.Parse(toType, fromValue.ToString(), ignoreCase:true);
+                    return fromValue => Enum.Parse(toType, fromValue.ToString(), ignoreCase: true);
                 }
                 if (toType.IsNullableType())
                 {
@@ -711,11 +711,25 @@ public static PropertyGetterDelegate CreateTypeConverter(Type fromType, Type toT
                 }
                 else if (toType.IsIntegerType())
                 {
+                    if (fromType.IsNullableType())
+                    {
+                        var genericArg = fromType.GenericTypeArguments()[0];
+                        if (genericArg.IsEnum())
+                        {
+                            return fromValue => Enum.ToObject(genericArg, fromValue);
+                        }
+                    }
                     return fromValue => Enum.ToObject(fromType, fromValue);
                 }
             }
             else if (toType.IsNullableType())
             {
+                var toTypeBaseType = toType.GenericTypeArguments()[0];
+                if (toTypeBaseType.IsEnum())
+                {
+                    if (fromType.IsEnum() || (fromType.IsNullableType() && fromType.GenericTypeArguments()[0].IsEnum()))
+                        return fromValue => Enum.ToObject(toTypeBaseType, fromValue);
+                }
                 return null;
             }
             else if (typeof(IEnumerable).IsAssignableFromType(fromType))
@@ -730,13 +744,13 @@ public static PropertyGetterDelegate CreateTypeConverter(Type fromType, Type toT
             }
             else if (toType.IsValueType())
             {
-                return fromValue => Convert.ChangeType(fromValue, toType, provider:null);
+                return fromValue => Convert.ChangeType(fromValue, toType, provider: null);
             }
             else
             {
-                return fromValue => 
+                return fromValue =>
                 {
-                    if (fromValue == null) 
+                    if (fromValue == null)
                         return fromValue;
 
                     var toValue = toType.CreateInstance();

tests/ServiceStack.Text.Tests/AutoMappingTests.cs

@@ -93,6 +93,11 @@ public class NullableEnumConversion
         public Color Color { get; set; }
     }
 
+    public class ReallyNullableEnumConversion
+    {
+        public Color? Color { get; set; }
+    }
+
     public class EnumConversion
     {
         public Color Color { get; set; }
@@ -209,7 +214,6 @@ public void Does_Enumnullableconversion_translate()
             var conversionDto = conversion.ConvertTo<NullableEnumConversionDto>();
 
             Assert.That(conversionDto.Color, Is.EqualTo(OtherColor.Green));
-
         }
 
         [Test]
@@ -221,6 +225,33 @@ public void Does_Enumconversion_translate()
             Assert.That(conversionDto.Color, Is.EqualTo(OtherColor.Green));
         }
 
+        [Test]
+        public void Does_ReallyEnumnullableconversion_translate()
+        {
+            var conversion = new ReallyNullableEnumConversion { Color = Color.Green };
+            var conversionDto = conversion.ConvertTo<NullableEnumConversionDto>();
+
+            Assert.That(conversionDto.Color, Is.EqualTo(OtherColor.Green));
+        }
+
+        [Test]
+        public void Does_RealyEnumconversion_translate()
+        {
+            var conversion = new ReallyNullableEnumConversion { Color = Color.Green };
+            var conversionDto = conversion.ConvertTo<EnumConversionDto>();
+
+            Assert.That(conversionDto.Color, Is.EqualTo(OtherColor.Green));
+        }
+
+        [Test]
+        public void Does_Enumconversion_translateFromNull()
+        {
+            var conversion = new ReallyNullableEnumConversion { Color = null };
+            var conversionDto = conversion.ConvertTo<EnumConversionDto>();
+
+            Assert.That(conversionDto.Color, Is.EqualTo(default(OtherColor)));
+        }
+
         [Test]
         public void Does_translate_nullableInt_to_and_from()
         {