C#类型转换

一个比较通用的类型转换不是个容易的事情，开发中获取UI数据，或从数据库取回数据（没有使用ORM）的情况下，类型转换都显得特别繁琐，曾经写过非常丑陋的类型转换代码，下面这个略好一点，也能用在对象自动映射中。

类型转换代码

    public class TypeHelper
    {
        /// <summary>
        /// 只应该用来转换基本类型
        /// </summary>
        /// <param name="value"></param>
        /// <param name="type"></param>
        /// <param name="defaultVal"></param>
        /// <returns></returns>
        public static object ChangeType(object value, Type type, object defaultVal = null)
        {
            // 不传入类型，直接返回
            if (type == null) return value;

            // 不传入转换值，返回类型的默认值
            if (value == null) return GetDefaultValue(type);

            // 类型一致不需要转换
            if (value.GetType() == type) return value;

            // Nullable类型，把类型转换为实际类型
            if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                type = type.GetGenericArguments()[0];
            }

            // 枚举类型处理
            if (type.IsEnum) return ConvertToEnum(value, type);

            // GUID类型处理
            if (value is string && type == typeof(Guid))
            {
                Guid guid;
                Guid.TryParse(value as string, out guid);
                return guid;
            }

            // bool类型增加与int类型的转换处理
            if (type == typeof(bool))
            {
                int i;
                if (TryConvertToInt(value, out i))
                {
                    value = i != 0;
                }
            }

            // 其他的转换
            try
            {
                return System.Convert.ChangeType(value, type);
            }
            catch
            {
                return defaultVal ?? GetDefaultValue(type);
            }
        }

        public static T ConvertTo<T>(object obj, T defalutValue = default(T))
        {
            return (T)TypeHelper.ChangeType(obj, typeof(T), defalutValue);
        }

        private static bool TryConvertToInt(object value, out int result)
        {
            try
            {
                result = (int)System.Convert.ChangeType(value, typeof(int));
                return true;
            }
            catch
            {
                result = default(int);
                return false;
            }
        }

        private static object ConvertToEnum(object value, Type type)
        {
            if (value is string)
            {
                try
                {
                    return Enum.Parse(type, value as string);
                }
                catch
                {
                    return Activator.CreateInstance(type);
                }
            }
            else
            {
                return Enum.ToObject(type, value);
            }
        }

        private static object GetDefaultValue(Type type)
        {
            if (!type.IsValueType) return null;

            if (!_defaultValues.ContainsKey(type))
                _defaultValues[type] = Activator.CreateInstance(type);

            return _defaultValues[type];
        }

        private static readonly Dictionary<Type, object> _defaultValues = new Dictionary<Type, object>();
    }

测试代码

    [TestClass()]
    public class TypeHelperTest
    {
        [TestMethod]
        public void NormalTest()
        {
            Assert.AreEqual('1', TypeHelper.ChangeType("1", typeof(char)));
            Assert.AreEqual(10, TypeHelper.ChangeType("10", typeof(int)));
            Assert.AreEqual(10m, TypeHelper.ChangeType("10", typeof(decimal)));
        }

        [TestMethod]
        public void NullArgumentTest()
        {
            Assert.AreEqual(null, TypeHelper.ChangeType(null, null));
            Assert.AreEqual(0, TypeHelper.ChangeType(null, typeof(int)));
            Assert.AreEqual(0m, TypeHelper.ChangeType(null, typeof(decimal)));
            Assert.AreEqual(null, TypeHelper.ChangeType(null, typeof(string)));
            Assert.AreEqual("10", TypeHelper.ChangeType("10", null));
            Assert.AreEqual(10, TypeHelper.ChangeType(10, null));
        }

        [TestMethod]
        public void NullableTypeTest()
        {
            Assert.AreEqual(null, TypeHelper.ChangeType(null, typeof(int?)));
            Assert.AreEqual(10, TypeHelper.ChangeType("10", typeof(int?)));
        }

        [TestMethod]
        public void BoolTypeTest()
        {
            Assert.AreEqual(true, TypeHelper.ChangeType("true", typeof(bool)));
            Assert.AreEqual(false, TypeHelper.ChangeType("false", typeof(bool)));

            Assert.AreEqual(true, TypeHelper.ChangeType("TRUE", typeof(bool)));
            Assert.AreEqual(false, TypeHelper.ChangeType("FALSE", typeof(bool)));

            Assert.AreEqual(true, TypeHelper.ChangeType("1", typeof(bool)));
            Assert.AreEqual(false, TypeHelper.ChangeType("0", typeof(bool)));

            Assert.AreEqual(true, TypeHelper.ChangeType(1, typeof(bool)));
            Assert.AreEqual(false, TypeHelper.ChangeType(0, typeof(bool)));

            Assert.AreEqual(true, TypeHelper.ChangeType("11", typeof(bool)));
            Assert.AreEqual(true, TypeHelper.ChangeType("-1", typeof(bool)));
        }

        [TestMethod]
        public void EnumTypeTest()
        {
            Assert.AreEqual(TestEnum.A, TypeHelper.ChangeType(1, typeof(TestEnum)));
            Assert.AreEqual(TestEnum.A, TypeHelper.ChangeType("1", typeof(TestEnum)));
            Assert.AreEqual(TestEnum.A, TypeHelper.ChangeType("A", typeof(TestEnum)));
            Assert.AreEqual((TestEnum)0, TypeHelper.ChangeType("a", typeof(TestEnum)));
        }

        [TestMethod]
        public void GuidTypeTest()
        {
            Assert.AreEqual(Guid.Empty, TypeHelper.ChangeType(null, typeof(Guid)));
            Assert.AreEqual(Guid.Empty, TypeHelper.ChangeType("dfdsfs", typeof(Guid)));
            Assert.AreEqual(new Guid("{244F8EE2-DDD3-486A-B3E7-9EFDEEE4488C}"), TypeHelper.ChangeType("{244F8EE2-DDD3-486A-B3E7-9EFDEEE4488C}", typeof(Guid)));
        }
    }

    public enum TestEnum
    {
        A = 1, B = 2
    }
}