Prevent conversion of the same type or interface

Author: javidsho

src/ConvertEx/TypeConverter.cs

@@ -69,6 +69,15 @@ public bool TryConvert(object value, Type targetType, IFormatProvider formatProv
                 return true;
             }
 
+            // test same type
+            var valueType = value.GetType();
+            var implementingInterface = targetType.IsInterface && valueType.GetInterfaces().Contains(targetType);
+            if (valueType == targetType || implementingInterface || valueType.IsSubclassOf(targetType))
+            {
+                convertedValue = value;
+                return true;
+            }
+
             // get conversion path
             var path = GetCachedConversionPath(value.GetType(), targetType);
             if (path == null)
@@ -93,6 +102,7 @@ public bool TryConvert(object value, Type targetType, IFormatProvider formatProv
 
         private IList<Type> GetCachedConversionPath(Type sourceType, Type destType)
         {
+            // TODO implement GetCachedConversionPath properly
             return GetConversionPath(sourceType, destType);
         }
 

tests/ConvertEx.Tests/TypeConverterTests.cs

@@ -11,11 +11,26 @@ public class TypeConverterTests
         [Theory]
         [InlineData(85, typeof(int), 85)]
         [InlineData("test", typeof(string), "test")]
-        public void Test_SameType(object value, Type targetType, object expectedValue)
+        [InlineData("test", typeof(object), "test")]
+        public void Test_NoConversion(object value, Type targetType, object expectedValue)
         {
             TestConversion(value, targetType, expectedValue);
         }
 
+        [Fact]
+        public void Test_NoSubClassConversion()
+        {
+            var b = new B();
+            TestConversion(b, typeof(A), b);
+        }
+
+        [Fact]
+        public void Test_NoImplementedInterfaceConversion()
+        {
+            var a = new A();
+            TestConversion(a, typeof(ITest), a);
+        }
+
         [Theory]
         [InlineData(85, typeof(double), 85d)]
         [InlineData(85, typeof(string), "85")]
@@ -29,13 +44,13 @@ public void Test_SimpleConversion(object value, Type targetType, object expected
         [Fact]
         public void Test_ValueToNullable()
         {
-            TestConversion(100, typeof(int?), (int?) 100);
+            TestConversion(100, typeof(int?), (int?)100);
         }
 
         [Fact]
         public void Test_NullableToValue()
         {
-            TestConversion((int?) 100, typeof(int), 100);
+            TestConversion((int?)100, typeof(int), 100);
         }
 
         [Fact]
@@ -59,5 +74,16 @@ private static void TestConversion(object value, Type targetType, object expecte
             var result = DotNetTools.ConvertEx.ConvertEx.ChangeType(value, targetType);
             Assert.Equal(expectedValue, result);
         }
+
+        private class A : ITest
+        {
+
+        }
+
+        private class B : A
+        {
+        }
+
+        private interface ITest { }
     }
 }