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類型，返回'\0'
        /// </summary>
        /// <param name="s">待轉換字符串</param>
        /// <returns>返回char類型值，如果傳入的對象不能轉換為char類型，返回'\0'</returns>
        public static char ToChar(string s)
        {
            return ToChar(s, '\0');
        }
        /// <summary>
        /// 將對象轉換為char類型，如果傳入的對象不能轉換為char類型，返回'\0'
        /// </summary>
        /// <param name="obj">待轉換對象</param>
        /// <returns>返回char類型值，如果傳入的對象不能轉換為char類型，返回'\0'</returns>
        public static char ToChar(object obj)
        {
            return ToChar(obj, '\0');
        }
        /// <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
    }
}