泛型数据类型转换

利用泛型转换数据类型，利用Convert.ChangeType 可以转换，其核心代码如下：

public static object ChangeType(object value, TypeCode typeCode, IFormatProvider provider)
{
    if ((value == null) && (((typeCode == TypeCode.Empty) || (typeCode == TypeCode.String)) || (typeCode == TypeCode.Object)))
    {
        return null;
    }
    IConvertible convertible = value as IConvertible;
    if (convertible == null)
    {
        throw new InvalidCastException(Environment.GetResourceString("InvalidCast_IConvertible"));
    }
    switch (typeCode)
    {
        case TypeCode.Empty:
            throw new InvalidCastException(Environment.GetResourceString("InvalidCast_Empty"));

        case TypeCode.Object:
            return value;

        case TypeCode.DBNull:
            throw new InvalidCastException(Environment.GetResourceString("InvalidCast_DBNull"));

        case TypeCode.Boolean:
            return convertible.ToBoolean(provider);

        case TypeCode.Char:
            return convertible.ToChar(provider);

        case TypeCode.SByte:
            return convertible.ToSByte(provider);

        case TypeCode.Byte:
            return convertible.ToByte(provider);

        case TypeCode.Int16:
            return convertible.ToInt16(provider);

        case TypeCode.UInt16:
            return convertible.ToUInt16(provider);

        case TypeCode.Int32:
            return convertible.ToInt32(provider);

        case TypeCode.UInt32:
            return convertible.ToUInt32(provider);

        case TypeCode.Int64:
            return convertible.ToInt64(provider);

        case TypeCode.UInt64:
            return convertible.ToUInt64(provider);

        case TypeCode.Single:
            return convertible.ToSingle(provider);

        case TypeCode.Double:
            return convertible.ToDouble(provider);

        case TypeCode.Decimal:
            return convertible.ToDecimal(provider);

        case TypeCode.DateTime:
            return convertible.ToDateTime(provider);

        case TypeCode.String:
            return convertible.ToString(provider);
    }
    throw new ArgumentException(Environment.GetResourceString("Arg_UnknownTypeCode"));
}

转换速度非常快，当然还是略慢于Type.Parse（如：int.Parse，decimal.Parse）但是朋友们很快就会发现他不提供容错处理，没有在转换错误的情况下给出默认值

没有办法只得改变一下，代码如下：

泛型数据类型转换#region 泛型数据类型转换

        /**//// <summary>
        /// 泛型数据类型转换
        /// </summary>
        /// <typeparam name="T">自定义数据类型</typeparam>
        /// <param name="value">传入需要转换的值</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        public static T ConvertType<T>(object value, T defaultValue)
        {
            return (T)ConvertToT<T>(value, defaultValue);
        }
        /**//// <summary>
        /// 转换数据类型
        /// </summary>
        /// <typeparam name="T">自定义数据类型</typeparam>
        /// <param name="myvalue">传入需要转换的值</param>
        /// <param name="defaultValue">默认值</param>
        /// <returns></returns>
        private static object ConvertToT<T>(object myvalue, T defaultValue)
        {
            TypeCode typeCode = System.Type.GetTypeCode(typeof(T));
            if (myvalue == null)
                return defaultValue;
            string value = myvalue.ToString(); 
            switch (typeCode)
            {
                case TypeCode.Boolean:
                    bool flag = false;
                    if (bool.TryParse(value, out flag))
                        return flag;
                    return defaultValue;
                case TypeCode.Char:
                    char c;
                    if (Char.TryParse(value, out c))
                        return c;
                    return defaultValue;
                case TypeCode.SByte:
                    sbyte s = 0;
                    if (SByte.TryParse(value, out s))
                        return s;
                    return defaultValue;
                case TypeCode.Byte:
                    byte b = 0;
                    if (Byte.TryParse(value, out b))
                        return b;
                    return defaultValue;
                case TypeCode.Int16:
                    Int16 i16 = 0;
                    if (Int16.TryParse(value, out i16))
                        return i16;
                    return defaultValue;
                case TypeCode.UInt16:
                    UInt16 ui16 = 0;
                    if (UInt16.TryParse(value, out ui16))
                        return ui16;
                    return defaultValue;
                case TypeCode.Int32:
                    int i = 0;
                    if (Int32.TryParse(value, out i))
                        return i;
                    return defaultValue;
                case TypeCode.UInt32:
                    UInt32 ui32 = 0;
                    if (UInt32.TryParse(value, out ui32))
                        return ui32;
                    return defaultValue;
                case TypeCode.Int64:
                    Int64 i64 = 0;
                    if (Int64.TryParse(value, out i64))
                        return i64;
                    return defaultValue;
                case TypeCode.UInt64:
                    UInt64 ui64 = 0;
                    if (UInt64.TryParse(value, out ui64))
                        return ui64;
                    return defaultValue;
                case TypeCode.Single:
                    Single single = 0;
                    if (Single.TryParse(value, out single))
                        return single;
                    return defaultValue;
                case TypeCode.Double:
                    double d = 0;
                    if (Double.TryParse(value, out d))
                        return d;
                    return defaultValue;
                case TypeCode.Decimal:
                    decimal de = 0;
                    if (Decimal.TryParse(value, out de))
                        return de;
                    return defaultValue;
                case TypeCode.DateTime:
                    DateTime dt;
                    if (DateTime.TryParse(value, out dt))
                        return dt;
                    return defaultValue;
                case TypeCode.String:
                    if (value.Length == 0)
                        return "";
                    return value.ToString();
            }
            throw new ArgumentNullException("defaultValue", "不能为Empty,Object,DBNull");
        }
        #endregion

虽然存在装箱与拆箱，性能上在放大到10000倍时会慢1.5~3倍，不过在我的机器上使用的时间为4ms

只是我有个疑问，都说装箱与拆箱耗费时间，不知道所说的耗费时间是个什么概念，我测试相差不是很大啊？

我的测试结果，各自运行10000次,时间 ms

1 ，我写转换函数：4.3167~7.3422

2，系统自带：3.4532~4.3453

3，int.TryParse ：3.9823~4.7843

4，int.Parse：3.4565~4.4532