Add support for using implicit/explicit casts of Value types in ConvertTo

Author: mythz

src/ServiceStack.Text/AutoMappingUtils.cs

@@ -87,11 +87,10 @@ public static T ConvertTo<T>(this object from, T defaultValue) =>
         public static T ConvertTo<T>(this object from, bool skipConverters)
         {
             if (from == null)
-                return default(T);
+                return default;
 
-            var fromType = from.GetType();
-            if (fromType == typeof(T))
-                return (T)from;
+            if (from is T t)
+                return t;
 
             return (T)ConvertTo(from, typeof(T), skipConverters);
         }
@@ -161,6 +160,32 @@ public static object ConvertTo(this object from, Type toType, bool skipConverter
             return to.PopulateWithNonDefaultValues(from);
         }
 
+        public static MethodInfo GetImplicitCastMethod(Type fromType, Type toType)
+        {
+            foreach (var mi in fromType.GetMethods(BindingFlags.Public | BindingFlags.Static))
+            {
+                if (mi.Name == "op_Implicit" && mi.ReturnType == toType &&
+                    mi.GetParameters().FirstOrDefault()?.ParameterType == fromType)
+                {
+                    return mi;
+                }
+            }
+            return null;
+        }
+        
+        public static MethodInfo GetExplicitCastMethod(Type fromType, Type toType)
+        {
+            foreach (var mi in toType.GetMethods(BindingFlags.Public | BindingFlags.Static))
+            {
+                if (mi.Name == "op_Explicit" && mi.ReturnType == toType &&
+                    mi.GetParameters().FirstOrDefault()?.ParameterType == fromType)
+                {
+                    return mi;
+                }
+            }
+            return null;
+        }
+        
         public static object ChangeValueType(object from, Type toType)
         {
             var s = from as string;
@@ -200,7 +225,15 @@ public static object ChangeValueType(object from, Type toType)
                         return srcNumberType.ToString(from);
                 }
             }
-            
+
+            var mi = GetImplicitCastMethod(fromType, toType);
+            if (mi != null)
+                return mi.Invoke(null, new[] { from });
+
+            mi = GetExplicitCastMethod(fromType, toType);
+            if (mi != null)
+                return mi.Invoke(null, new[] { from });
+
             if (s != null)
                 return TypeSerializer.DeserializeFromString(s, toType);
 

tests/ServiceStack.Text.Tests/AutoMappingTests.cs

@@ -1098,5 +1098,54 @@ public void To_ValueType_on_null_or_empty_string_returns_default_value()
             Assert.That("".ConvertTo<int>(), Is.EqualTo(default(int)));
         }
 
+        struct A
+        {
+            public int Id { get; }
+            public A(int id) => Id = id;
+            public static implicit operator B(A from) => new B(from.Id);
+        }
+
+        struct B
+        {
+            public int Id { get; }
+            public B(int id) => Id = id;
+            public static implicit operator A(B from) => new A(from.Id);
+        }
+
+        [Test]
+        public void Can_convert_between_structs_with_implicit_casts()
+        {
+            var a = new A(1);
+            var b = a;
+            Assert.That(b.Id, Is.EqualTo(a.Id));
+
+            b = a.ConvertTo<B>();
+            Assert.That(b.Id, Is.EqualTo(a.Id));
+        }
+
+        struct C
+        {
+            public int Id { get; }
+            public C(int id) => Id = id;
+            public static explicit operator C(D from) => new C(from.Id);
+        }
+
+        struct D
+        {
+            public int Id { get; }
+            public D(int id) => Id = id;
+            public static explicit operator D(C from) => new D(from.Id);
+        }
+
+        [Test]
+        public void Can_convert_between_structs_with_explicit_casts()
+        {
+            var c = new C(1);
+            var d = (D)c;
+            Assert.That(d.Id, Is.EqualTo(c.Id));
+
+            d = c.ConvertTo<D>();
+            Assert.That(d.Id, Is.EqualTo(c.Id));
+        }
     }
 }