C#安全类型转换基于convert

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Globalization;
namespace xxxx
{
    public static class SafeConvert
    {
        /// <summary>
        /// 判断对像是否是空对象，例数据表中某列内某行为空
        /// </summary>
        /// <param name="obj">侍判断的对象</param>
        /// <returns>对像是否是空对象</returns>
        public static bool IsDBNull(object obj)
        {
            return Convert.IsDBNull(obj);
        }
        #region Conver To Methods
        /// <summary>
        /// 生成Guid
        /// </summary>
        /// <param name="obj">obj的ToString方法需要能够返回32位的数字字符串</param>
        /// <returns>生成的System.Guid对象,传入的对象为空，则返回Guid.Empty</returns>
        public static Guid ToGuid(object obj)
        {
            if (obj != null && obj != DBNull.Value)
            {
                try
                {
                    return new Guid(obj.ToString());
                }
                catch
                {
                    return Guid.Empty;
                }
            }
            return Guid.Empty;
        }
        /// <summary>
        /// 将一个对象转达换为一个TimeSpan对象
        /// </summary>
        /// <param name="obj">侍转换对象</param>
        /// <returns>一个TimeSpan对象</returns>
        public static TimeSpan ToTimeSpan(object obj)
        {
            return ToTimeSpan(obj, TimeSpan.Zero);
        }
        /// <summary>
        /// 将一个对象转换成TimeSpan,当参数对象为空时，返回缺省值
        /// </summary>
        /// <param name="obj">侍转换的对象</param>
        /// <param name="defaultValue">传入对象为空时，设置的缺省值</param>
        /// <returns>返回一个TimeSpan对象</returns>
        public static TimeSpan ToTimeSpan(object obj, TimeSpan defaultValue)
        {
            if (obj != null)
                return ToTimeSpan(obj.ToString(), defaultValue);

            return defaultValue;
        }
        /// <summary>
        /// 将一个字符串转换成TimeSpan,当参数为空时，返回缺省值
        /// </summary>
        /// <param name="s">侍转换的字符串</param>
        /// <param name="defaultValue">传入字符串为空时，设置的缺省值</param>
        /// <returns>返回一个TimeSpan对象</returns>
        public static TimeSpan ToTimeSpan(string s, TimeSpan defaultValue)
        {
            TimeSpan result;
            bool success = TimeSpan.TryParse(s, out result);

            return success ? result : defaultValue;
        }
        /// <summary>
        /// 将一个字符串转换成TimeSpan
        /// </summary>
        /// <param name="s">侍转换的字符串</param>
        /// <returns>返回一个TimeSpan对象</returns>
        public static TimeSpan ToTimeSpan(string s)
        {
            return ToTimeSpan(s, TimeSpan.Zero);
        }
        /// <summary>
        /// 将一个对象转换为字符串
        /// </summary>
        /// <param name="obj">侍转换的对象</param>
        /// <returns>返回一个字符串，当对象为空时，返回string.Empty</returns>
        public static string ToString(object obj)
        {
            if (obj != null) return obj.ToString();
            return string.Empty;
        }
        /// <summary>
        /// 判断字符串对象是否为空，如果是空，则返回string.Empty；
        /// </summary>
        /// <param name="s">侍转换的字符串</param>
        /// <returns>返回一个字符串</returns>
        public static string ToString(string s)
        {
            return ToString(s, string.Empty);
        }
        /// <summary>
        /// 判断字符串对象是否为空，如果是空，则返回一个缺省值
        /// </summary>
        /// <param name="s">侍转换字符串</param>
        /// <param name="defaultString">字符串缺省值</param>
        /// <returns>返回一个字符串，当对象为空时，返回缺省值</returns>
        public static string ToString(string s, string defaultString)
        {
            if (s == null) return defaultString;
            return s.ToString();
        }
        /// <summary>
        /// 判断对象是否为空，如果是空，则返回一个缺省值
        /// </summary>
        /// <param name="s">侍转换对象</param>
        /// <param name="defaultString">字符串缺省值</param>
        /// <returns>返回一个字符串，当对象为空时，返回缺省值</returns>
        public static string ToString(object s, string defaultString)
        {
            if (s == null) return defaultString;

            return s.ToString();
        }
        /// <summary>
        /// 将字符串转换为double类型，如果传入的字符串不能转换为double类型，返回一个缺省值
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <param name="defaultValue">double缺省值</param>
        /// <returns>返回double类型值，如果传入的字符串不能转换为double类型，返回一个缺省值</returns>
        public static double ToDouble(string s, double defaultValue)
        {
            double result;
            bool success = double.TryParse(s, out result);

            return success ? result : defaultValue;
        }
        /// <summary>
        /// 将字符串转换为double类型，如果传入的字符串不能转换为double类型，返回0
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <returns>返回double类型值，如果传入的字符串不能转换为double类型，返回0</returns>
        public static double ToDouble(string s)
        {
            return ToDouble(s, 0);
        }
       /// <summary>
        /// 将对象转换为double类型，如果传入的对象不能转换为double类型，返回0
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <returns>返回double类型值，如果传入的对象不能转换为double类型，返回0</returns>
        public static double ToDouble(object obj)
        {
            return ToDouble(obj, 0);
        }
        /// <summary>
        /// 将对象转换为double类型，如果传入的对象不能转换为double类型，返回缺省值
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <param name="defaultValue">缺省的double值</param>
        /// <returns>返回double类型值，如果传入的对象不能转换为double类型，返回缺省值</returns>
        public static double ToDouble(object obj, double defaultValue)
        {
            if (obj != null)
                return ToDouble(obj.ToString(), defaultValue);
            return defaultValue;
        }
        /// <summary>
        /// 将对象转换为float类型，如果传入的对象不能转换为float类型，返回缺省值
        /// </summary>
        /// <param name="s">待转换字符串对象</param>
        /// <param name="defaultValue">缺省的float值</param>
        /// <returns>返回float类型值，如果传入的对象不能转换为float类型，返回缺省值</returns>
        public static float ToSingle(string s, float defaultValue)
        {
            float result;
            bool success = float.TryParse(s, out result);
            return success ? result : defaultValue;
        }
        /// <summary>
        /// 将对象转换为float类型，如果传入的对象不能转换为float类型，返回0
        /// </summary>
        /// <param name="s">待转换对象</param>
        /// <returns>返回float类型值，如果传入的对象不能转换为float类型，返回0</returns>
        public static float ToSingle(string s)
        {
            return ToSingle(s, 0);
        }
        /// <summary>
        /// 将对象转换为float类型，如果传入的对象不能转换为float类型，返回0
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <returns>返回float类型值，如果传入的对象不能转换为float类型，返回0</returns>
        public static float ToSingle(object obj)
        {
            return ToSingle(obj, 0);
        }
        /// <summary>
        /// 将对象转换为float类型，如果传入的对象不能转换为float类型，返回缺省值
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <param name="defaultValue">float缺省值</param>
        /// <returns>返回float类型值，如果传入的对象不能转换为float类型，返回缺省值</returns>
        public static float ToSingle(object obj, float defaultValue)
        {
            if (obj != null)
                return ToSingle(obj.ToString(), defaultValue);
            return defaultValue;
        }
        /// <summary>
        /// 将对象转换为decimal类型，如果传入的对象不能转换为decimal类型，返回缺省值
        /// </summary>
        /// <param name="s">待转换对象</param>
        /// <param name="defaultValue">decimal缺省值</param>
        /// <returns>返回decimal类型值，如果传入的对象不能转换为decimal类型，返回缺省值</returns>
        public static decimal ToDecimal(string s, decimal defaultValue)
        {
            decimal result;
            bool success = decimal.TryParse(s, out result);

            return success ? result : defaultValue;
        }
        /// <summary>
        /// 将对象转换为decimal类型，如果传入的对象不能转换为decimal类型，返回0
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <returns>返回decimal类型值，如果传入的对象不能转换为decimal类型，返回0</returns>
        public static decimal ToDecimal(string s)
        {
            return ToDecimal(s, 0);
        }
        /// <summary>
        /// 将对象转换为decimal类型，如果传入的对象不能转换为decimal类型，返回0
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <returns>返回decimal类型值，如果传入的对象不能转换为decimal类型，返回0</returns>
        public static decimal ToDecimal(object obj)
        {
            return ToDecimal(obj, 0);
        }
        /// <summary>
        /// 将对象转换为decimal类型，如果传入的对象不能转换为decimal类型，返回缺省值
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <param name="defaultValue">decimal缺省值</param>
        /// <returns>返回decimal类型值，如果传入的对象不能转换为decimal类型，返回缺省值</returns>
        public static decimal ToDecimal(object obj, decimal defaultValue)
        {
            if (obj != null)
                return ToDecimal(obj.ToString(), defaultValue);

            return defaultValue;
        }
        /// <summary>
        /// 将对象转换为float类型，如果传入的对象不能转换为float类型，返回缺省值
        /// </summary>
        /// <param name="s">待转换对象</param>
        /// <param name="defaultValue">float缺省值</param>
        /// <returns>返回float类型值，如果传入的对象不能转换为float类型，返回缺省值</returns>
        public static float ToFloat(string s, float defaultValue)
        {
            float result;
            bool success = float.TryParse(s, out result);

            return success ? result : defaultValue;
        }
        /// <summary>
        /// 将对象转换为float类型，如果传入的对象不能转换为float类型，返回0
        /// </summary>
        /// <param name="s">待转换字符串对象</param>
        /// <returns>返回float类型值，如果传入的对象不能转换为float类型，返回0</returns>
        public static float ToFloat(string s)
        {
            return ToFloat(s, 0);
        }
        /// <summary>
        /// 将对象转换为float类型，如果传入的对象不能转换为float类型，返回0
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <returns>返回float类型值，如果传入的对象不能转换为float类型，返回0</returns>
        public static float ToFloat(object obj)
        {
            return ToFloat(obj, 0);
        }
        /// <summary>
        /// 将对象转换为float类型，如果传入的对象不能转换为float类型，返回缺省值
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <param name="defaultValue">float缺省值</param>
        /// <returns>返回float类型值，如果传入的对象不能转换为float类型，返回缺省值</returns>
        public static float ToFloat(object obj, float defaultValue)
        {
            if (obj != null)
                return ToFloat(obj.ToString(), defaultValue);

            return defaultValue;
        }
        /// <summary>
        /// 将对象转换为bool类型，如果传入的对象不能转换为bool类型，返回缺省值
        /// </summary>
        /// <param name="s">待转换对象</param>
        /// <param name="defaultValue">bool缺省值</param>
        /// <returns>返回float类型值，如果传入的对象不能转换为bool类型，返回缺省值</returns>
        public static bool ToBoolean(string s, bool defaultValue)
        {
            //修复1被转换为false的BUG
            if (s == "1")
                return true;
            bool result;
            bool success = bool.TryParse(s, out result);

            return success ? result : defaultValue;
        }
        /// <summary>
        /// 将对象转换为bool类型，如果传入的对象不能转换为bool类型，返回false
        /// </summary>
        /// <param name="s">待转换字符串对象</param>
        /// <returns>返回bool类型值，如果传入的对象不能转换为bool类型，返回false</returns>
        public static bool ToBoolean(string s)
        {
            return ToBoolean(s, false);
        }
        /// <summary>
        /// 将对象转换为bool类型，如果传入的对象不能转换为bool类型，返回缺省值
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <returns>返回float类型值，如果传入的对象不能转换为bool类型，返回缺省值</returns>
        public static bool ToBoolean(object obj)
        {
            return ToBoolean(obj, false);
        }

        /// <summary>
        /// 将对象转换为bool类型，如果传入的对象不能转换为bool类型，返回缺省值
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <param name="defaultValue">bool缺省值</param>
        /// <returns>返回float类型值，如果传入的对象不能转换为bool类型，返回缺省值</returns>
        public static bool ToBoolean(object obj, bool defaultValue)
        {
            if (obj != null)
                return ToBoolean(obj.ToString(), defaultValue);

            return defaultValue;
        }
        /// <summary>
        /// 将对象转换为char类型，如果传入的对象不能转换为char类型，返回缺省值
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <param name="defaultValue">char缺省值</param>
        /// <returns>返回char类型值，如果传入的对象不能转换为char类型，返回缺省值</returns>
        public static char ToChar(string s, char defaultValue)
        {
            char result;
            bool success = char.TryParse(s, out result);

            return success ? result : defaultValue;
        }
        /// <summary>
        /// 将字符串转换为char类型，如果传入的对象不能转换为char类型，返回''
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <returns>返回char类型值，如果传入的对象不能转换为char类型，返回''</returns>
        public static char ToChar(string s)
        {
            return ToChar(s, '');
        }
        /// <summary>
        /// 将对象转换为char类型，如果传入的对象不能转换为char类型，返回''
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <returns>返回char类型值，如果传入的对象不能转换为char类型，返回''</returns>
        public static char ToChar(object obj)
        {
            return ToChar(obj, '');
        }
        /// <summary>
        /// 将对象转换为char类型，如果传入的对象为空，返回缺省值
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <param name="defaultValue">char缺省值</param>
        /// <returns>返回char类型值，如果传入的对象为空，返回缺省值</returns>
        public static char ToChar(object obj, char defaultValue)
        {
            if (obj != null)
                return ToChar(obj.ToString(), defaultValue);

            return defaultValue;
        }
        /// <summary>
        /// 将字符串转换为byte类型，如果传入的对象不能转换为byte类型，返回缺省值
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <param name="defaultValue">byte缺省值</param>
        /// <returns>返回byte类型值，如果传入的对象不能转换为byte类型，返回缺省值</returns>
        public static byte ToByte(string s, byte defaultValue)
        {
            byte result;
            bool success = byte.TryParse(s, out result);

            return success ? result : defaultValue;
        }
        /// <summary>
        /// 将对象转换为byte类型，如果传入的对象不能转换为byte类型，返回0
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <param name="defaultValue">char缺省值</param>
        /// <returns>返回byte类型值，如果传入的对象不能转换为byte类型，返回0</returns>
        public static byte ToByte(string s)
        {
            return ToByte(s, 0);
        }
        /// <summary>
        /// 将对象转换为byte类型，如果传入的对象不能转换为byte类型，返回0
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <param name="defaultValue">char缺省值</param>
        /// <returns>返回byte类型值，如果传入的对象不能转换为byte类型，返回0</returns>
        public static byte ToByte(object obj)
        {
            return ToByte(obj, 0);
        }
        /// <summary>
        /// 将对象转换为byte类型，如果传入的对象不能转换为byte类型，返回缺省值
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <param name="defaultValue">byte缺省值</param>
        /// <returns>返回byte类型值，如果传入的对象不能转换为byte类型，返回缺省值</returns>
        public static byte ToByte(object obj, byte defaultValue)
        {
            if (obj != null)
                return ToByte(obj.ToString(), defaultValue);

            return defaultValue;
        }
        /// <summary>
        /// 将字符串对象转换为sbyte类型，如果传入字符串的对象不能转换为sbyte类型，返回缺省值
        /// </summary>
        /// <param name="s">待转换对象</param>
        /// <param name="defaultValue">sbyte缺省值</param>
        /// <returns>返回sbyte类型值，如果传入的对象不能转换为sbyte类型，返回缺省值</returns>
        public static sbyte ToSByte(string s, sbyte defaultValue)
        {
            sbyte result;
            bool success = sbyte.TryParse(s, out result);

            return success ? result : defaultValue;
        }
        /// <summary>
        /// 将对象转换为sbyte类型，如果传入的对象不能转换为sbyte类型，返回0
        /// </summary>
        /// <param name="s">待转换对象</param>
        /// <returns>返回sbyte类型值，如果传入的对象不能转换为sbyte类型，返回0</returns>
        public static sbyte ToSByte(string s)
        {
            return ToSByte(s, 0);
        }
        /// <summary>
        /// 将对象转换为sbyte类型，如果传入的对象不能转换为sbyte类型，返回0
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <returns>返回sbyte类型值，如果传入的对象不能转换为sbyte类型，返回0</returns>
        public static sbyte ToSByte(object obj)
        {
            return ToSByte(obj, 0);
        }
        /// <summary>
        /// 将对象转换为sbyte类型，如果传入的对象为空，返回缺省值
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <param name="defaultValue">sbyte缺省值</param>
        /// <returns>返回sbyte类型值，如果传入的对象为空，返回缺省值</returns>
        public static sbyte ToSByte(object obj, sbyte defaultValue)
        {
            if (obj != null)
                return ToSByte(obj.ToString(), defaultValue);

            return defaultValue;
        }
        /// <summary>
        /// 将对象转换为short类型，如果传入的对象不能转换为short类型，返回缺省值
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <param name="defaultValue">short缺省值</param>
        /// <returns>返回short类型值，如果传入的对象不能转换为short类型，返回缺省值</returns>
        public static short ToInt16(string s, short defaultValue)
        {
            short result;
            bool success = short.TryParse(s, out result);

            return success ? result : defaultValue;
        }
        /// <summary>
        /// 将字符串转换为short类型，如果传入的字符串不能转换为short类型，返回0
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <returns>返回short类型值，如果传入的字符串不能转换为short类型，返回0</returns>
        public static short ToInt16(string s)
        {
            return ToInt16(s, 0);
        }
        /// <summary>
        /// 将对象转换为short类型，如果传入的对象不能转换为short类型，返回0
        /// </summary>
        /// <param name="obj">待转换字符串</param>
        /// <returns>返回short类型值，如果传入的对象不能转换为short类型，返回0</returns>
        public static short ToInt16(object obj)
        {
            return ToInt16(obj, 0);
        }
        /// <summary>
        /// 将字符串转换为short类型，如果传入的字符串为空，返回缺省值
        /// </summary>
        /// <param name="obj">待转换字符串</param>
        /// <param name="defaultValue">short缺省值</param>
        /// <returns>返回short类型值，如果传入的字符串为空，返回缺省值</returns>
        public static short ToInt16(object obj, short defaultValue)
        {
            if (obj != null)
                return ToInt16(obj.ToString(), defaultValue);

            return defaultValue;
        }

        /// <summary>
        /// 将字符串转换为ushort类型，如果传入的字符串不能转换为ushort，返回缺省值
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <param name="defaultValue">ushort缺省值</param>
        /// <returns>返回ushort类型值，如果传入的字符串不能转换为ushort，返回缺省值</returns>
        public static ushort ToUInt16(string s, ushort defaultValue)
        {
            ushort result;
            bool success = ushort.TryParse(s, out result);

            return success ? result : defaultValue;
        }
        /// <summary>
        /// 将字符串转换为ushort类型，如果传入的字符串不能转换为ushort，返回0
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <returns>返回ushort类型值，如果传入的字符串不能转换为ushort，返回0</returns>
        public static ushort ToUInt16(string s)
        {
            return ToUInt16(s, 0);
        }
        /// <summary>
        /// 将对象转换为ushort类型，如果传入的对象不能转换为ushort，返回0
        /// </summary>
        /// <param name="obj">待转换字符串</param>
        /// <returns>返回ushort类型值，如果传入的对象不能转换为ushort，返回0</returns>
        public static ushort ToUInt16(object obj)
        {
            return ToUInt16(obj, 0);
        }

        /// <summary>
        /// 将字符串转换为ushort类型，如果传入的字符串不能转换为ushort，返回0
        /// </summary>
        /// <param name="obj">待转换字符串</param>
        /// <param name="defaultValue">ushort缺省值</param>
        /// <returns>返回ushort类型值，如果传入的字符串不能转换为ushort，返回0</returns>
        public static ushort ToUInt16(object obj, ushort defaultValue)
        {
            if (obj != null)
                return ToUInt16(obj.ToString(), defaultValue);

            return defaultValue;
        }
        /// <summary>
        /// 将字符串转换为int类型，如果传入的字符串不能转换为int，返回缺省值
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <param name="defaultValue">int缺省值</param>
        /// <returns>返回int类型值，如果传入的字符串不能转换为int，返回缺省值</returns>
        public static int ToInt32(string s, int defaultValue)
        {
            int result;
            bool success = int.TryParse(s, out result);

            return success ? result : defaultValue;
        }

        /// <summary>
        /// 将字符串转换为int类型，如果传入的字符串不能转换为int，返回0
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <returns>返回int类型值，如果传入的字符串不能转换为int，返回0</returns>
        public static int ToInt32(string s)
        {
            return ToInt32(s, 0);
        }
        /// <summary>
        /// 将对象转换为int类型，如果传入的字符串不能转换为int，返回0
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <returns>返回int类型值，如果传入的对象不能转换为int，返回0</returns>
        public static int ToInt32(object obj)
        {
            return ToInt32(obj, 0);
        }
        /// <summary>
        /// 将对象转换为int类型，如果传入的字符串不能转换为int，返回缺省值
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <param name="defaultValue">int缺省值</param>
        /// <returns>返回int类型值，如果传入的字符串不能转换为int，返回缺省值</returns>
        public static int ToInt32(object obj, int defaultValue)
        {
            if (obj != null)
                return ToInt32(obj.ToString(), defaultValue);

            return defaultValue;
        }
        /// <summary>
        /// 将字符串对象转换为uint类型，如果传入的字符串不能转换为uint，返回缺省值
        /// </summary>
        /// <param name="s">待转换字符串对象</param>
        /// <param name="defaultValue">uint缺省值</param>
        /// <returns>返回uint类型值，如果传入的字符串不能转换为uint，返回缺省值</returns>
        public static uint ToUInt32(string s, uint defaultValue)
        {
            uint result;
            bool success = uint.TryParse(s, out result);

            return success ? result : defaultValue;
        }
        /// <summary>
        /// 将字符串对象转换为uint类型，如果传入的字符串不能转换为uint，返回0
        /// </summary>
        /// <param name="s">待转换字符串对象</param>
        /// <returns>返回uint类型值，如果传入的字符串不能转换为uint，返回0</returns>
        public static uint ToUInt32(string s)
        {
            return ToUInt32(s, 0);
        }

        /// <summary>
        /// 将对象转换为uint类型，如果传入的对象不能转换为uint，返回0
        /// </summary>
        /// <param name="obj">待转换</param>
        /// <returns>返回uint类型值，如果传入的对象不能转换为uint，返回0</returns>
        public static uint ToUInt32(object obj)
        {
            return ToUInt32(obj, 0);
        }
        /// <summary>
        /// 将对象转换为uint类型，如果传入的对象不能转换为uint，返回缺省值
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <param name="defaultValue">uint缺省值</param>
        /// <returns>返回uint类型值，如果传入的对象不能转换为uint，返回缺省值</returns>
        public static uint ToUInt32(object obj, uint defaultValue)
        {
            if (obj != null)
                return ToUInt32(obj.ToString(), defaultValue);

            return defaultValue;
        }
        /// <summary>
        /// 将字符串转换为long类型，如果传入的字符串不能转换为long，返回缺省值
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <param name="defaultValue">long缺省值</param>
        /// <returns>返回long类型值，如果传入的字符串不能转换为long，返回缺省值</returns>
        public static long ToInt64(string s, long defaultValue)
        {
            long result;
            bool success = long.TryParse(s, out result);

            return success ? result : defaultValue;
        }
        /// <summary>
        /// 将字符串转换为long类型，如果传入的字符串不能转换为long，返回0
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <returns>返回long类型值，如果传入的字符串不能转换为long，返回0</returns>
        public static long ToInt64(string s)
        {
            return ToInt64(s, 0);
        }
        /// <summary>
        /// 将对象转换为long类型，如果传入的对象不能转换为long，返回0
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <returns>返回long类型值，如果传入的对象不能转换为long，返回0</returns>
        public static long ToInt64(object obj)
        {
            return ToInt64(obj, 0);
        }

        /// <summary>
        /// 将对象转换为long类型，如果传入的对象不能转换为long，返回缺省值
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <param name="defaultValue">long缺省值</param>
        /// <returns>返回long类型值，如果传入的对象不能转换为long，返回缺省值</returns>
        public static long ToInt64(object obj, long defaultValue)
        {
            if (obj != null)
                return ToInt64(obj.ToString(), defaultValue);

            return defaultValue;
        }
        /// <summary>
        /// 将字符串转换为ulong类型，如果传入的字符串不能转换为ulong，返回缺省值
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <param name="defaultValue">ulong缺省值</param>
        /// <returns>返回ulong类型值，如果传入的字符串不能转换为ulong，返回缺省值</returns>
        public static ulong ToUInt64(string s, ulong defaultValue)
        {
            ulong result;
            bool success = ulong.TryParse(s, out result);

            return success ? result : defaultValue;
        }
        /// <summary>
        /// 将字符串转换为ulong类型，如果传入的字符串不能转换为ulong，返回0
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <returns>返回ulong类型值，如果传入的字符串不能转换为ulong，返回0</returns>
        public static ulong ToUInt64(string s)
        {
            return ToUInt64(s, 0);
        }
        /// <summary>
        /// 将对象转换为ulong类型，如果传入的对象不能转换为ulong，返回0
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <returns>返回ulong类型值，如果传入的对象不能转换为ulong，返回0</returns>
        public static ulong ToUInt64(object obj)
        {
            return ToUInt64(obj, 0);
        }
        /// <summary>
        /// 将对象转换为ulong类型，如果传入的对象不能转换为ulong，返回缺省值
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <param name="defaultValue">ulong缺省值</param>
        /// <returns>返回ulong类型值，如果传入的对象不能转换为ulong，返回缺省值</returns>
        public static ulong ToUInt64(object obj, ulong defaultValue)
        {
            if (obj != null)
                return ToUInt64(obj.ToString(), defaultValue);

            return defaultValue;
        }
        /// <summary>
        /// 将字符串转换为DateTime类型，如果传入的字符串不能转换为DateTime，返回缺省值
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <param name="defaultValue">DateTime缺省值</param>
        /// <returns>返回DateTime类型值，如果传入的字符串不能转换为DateTime，返回缺省值</returns>
        public static DateTime ToDateTime(string s, DateTime defaultValue)
        {
            DateTime result;
            bool success = DateTime.TryParse(s, out result);

            return success ? result : defaultValue;
        }

        /// <summary>
        /// 将字符串转换为DateTime类型，如果传入的字符串不能转换为DateTime，返回DateTime.MinValue
        /// </summary>
        /// <param name="s">待转换字符串</param>
        /// <returns>返回DateTime类型值，如果传入的字符串不能转换为DateTime，返回DateTime.MinValue</returns>
        public static DateTime ToDateTime(string s)
        {
            return ToDateTime(s, DateTime.MinValue);
        }
        /// <summary>
        /// 将对象转换为DateTime类型，如果传入的对象不能转换为DateTime，返回DateTime.MinValue
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <returns>返回DateTime类型值，如果传入的对象不能转换为DateTime，返回DateTime.MinValue</returns>
        public static DateTime ToDateTime(object obj)
        {
            return ToDateTime(obj, DateTime.MinValue);
        }
        /// <summary>
        /// 将对象转换为DateTime类型，如果传入的对象不能转换为DateTime，返回DateTime.MinValue
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <returns>返回DateTime类型值，如果传入的对象不能转换为DateTime，返回DateTime.MinValue</returns>
        public static DateTime ToDateTime2(DateTime obj, string format)
        {
            DateTimeFormatInfo dtFormat = new DateTimeFormatInfo();
            dtFormat.ShortDatePattern = format;
            return Convert.ToDateTime(obj, dtFormat);
        }
        /// <summary>
        /// 将对象转换为DateTime类型，如果传入的对象不能转换为DateTime，返回缺省值
        /// </summary>
        /// <param name="obj">待转换对象</param>
        /// <param name="defaultValue">DateTime缺省值</param>
        /// <returns>返回DateTime类型值，如果传入的对象不能转换为DateTime，返回缺省值</returns>
        public static DateTime ToDateTime(object obj, DateTime defaultValue)
        {
            if (obj != null)
                return ToDateTime(obj.ToString(), defaultValue);

            return defaultValue;
        }
        /// <summary>
        /// 将字符串类型转换成枚举类型，不忽略大小写
        /// </summary>
        /// <param name="enumType">型别</param>
        /// <param name="text">枚举值</param>
        /// <param name="defaultValue">缺省枚举值</param>
        /// <returns>返回一个enumType的对象，其值是text,如果转换失败，返回缺省值</returns>
        public static object ToEnum(Type enumType, string text, object defaultValue)
        {
            if (Enum.IsDefined(enumType, text))
            {
                return Enum.Parse(enumType, text, false);
            }

            return defaultValue;
        }
        /// <summary>
        /// 将对象转换成枚举类型，不忽略大小写
        /// </summary>
        /// <param name="enumType">型别</param>
        /// <param name="obj">枚举值</param>
        /// <param name="defaultValue">缺省枚举值</param>
        /// <returns>返回一个enumType的对象，其值是text,如果转换失败，返回缺省值</returns>
        public static object ToEnum(Type enumType, object obj, object defaultValue)
        {
            if (obj != null)
                return ToEnum(enumType, obj.ToString(), defaultValue);

            return defaultValue;
        }
        /// <summary>
        /// 创建一个枚举，其值为index
        /// </summary>
        /// <param name="enumType">型别</param>
        /// <param name="index">枚举值</param>
        /// <returns>返回一个enumType的枚举，值为index</returns>
        public static object ToEnum(Type enumType, int index)
        {
            return Enum.ToObject(enumType, index);
        }

        /// <summary>
        /// Json字符串转为List对象
        /// </summary>
        /// <typeparam name="T">对象</typeparam>
        /// <param name="json">Json字符串</param>
        /// <returns></returns>
        public static List<T> JsonStringToList<T>(string json, out string msg)
        {
            msg = string.Empty;
            try
            {
                return JsonConvert.DeserializeObject<List<T>>(json);
            }
            catch (Exception ex)
            {
                msg = ex.Message;
                return null;
            }
        }
        #endregion
    }
}