using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.Text;
using System.Text.RegularExpressions;


namespace DataexchangeServer
{
    /// <summary>
    /// ×Ö·û´®º¯Êý¸¨ÖúÀà¡£
    /// </summary>
    public class StringHelper
    {
        /// <summary>
        /// SQL±í´ïʽ·Ö½â±í´ïʽÖеÄÌØÊâ²ÎÊý£¬°üÀ¨²ÎÊý¡¢¸¸¼Ç¼¡¢¼Ç¼¡¢È«¾Ö±äÁ¿µÈ¡£
        /// Àý£º½«±í´ïʽ
        ///     Éú²úÊý>90 AND ¹¤ºÅ=para:P0123 OR DMA002=parent:DMA001 OR Ãû³Æ=field:D01 OR AA=@@01 
        ///     ÖеÄÌØÊâ²ÎÊý²éÕÒ³öÀ´:para:P0123,parent:DMA001,field:D01,@@01
        /// </summary>
        public const string Rggex_SqlExpression = @"\w+[><=]\w*((para|parent|field|@@)([:]*)+\w*)";

        private static Regex RegexBr = new Regex(@"(\r\n)", RegexOptions.IgnoreCase);

        /// <summary>
        /// µÃµ½ÕýÔò±àÒë²ÎÊýÉèÖÃ
        /// </summary>
        /// <returns></returns>
        public static RegexOptions GetRegexCompiledOptions()
        {
            #if NET1
               return RegexOptions.Compiled;
            #else
               return RegexOptions.None;
            #endif
        }

        /// <summary>
        /// ·µ»Ø×Ö·û´®Õæʵ³¤¶È, 1¸öºº×Ö³¤¶ÈΪ2¡£
        /// </summary>
        /// <returns></returns>
        public static int GetStringLength(string str)
        {
            return Encoding.Default.GetBytes(str).Length;
        }

        /// <summary>
        /// ÅжÏ×Ö·û´®µÄ°üº¬¹Øϵ¡£
        /// </summary>
        /// <param name="str">±»°üº¬µÄ×Ö·û´®¡£</param>
        /// <param name="stringArray">ÒÔÖ¸¶¨·Ö¸ô·ûÃèÊöµÄ×Ö·û´®Êý×é¡£</param>
        /// <param name="stringSplit">×Ö·û´®Êý×éµÄ·Ö¸ô·û¡£</param>
        /// <returns>Èç¹û±»°üº¬µÄ×Ö·û´®ÔÚÖ¸¶¨×Ö·û´®Êý×éÖУ¬Ôò·µ»Øtrue,·ñÔò·µ»Øfalse¡£</returns>
        public static bool IsCompriseString(string str, string stringArray, string stringSplit)
        {
            if (stringArray == "" || stringArray == null)
            {
                return false;
            }

            str = str.ToLower();
            string[] array = SafeSplitString(stringArray.ToLower(), stringSplit);
            for (int i = 0; i < stringArray.Length; i++)
            {
                //string t1 = str;
                //string t2 = stringArray[i];
                if (str.IndexOf(array[i]) > -1)
                {
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// ÅжÏÖ¸¶¨×Ö·û´®ÔÚÖ¸¶¨×Ö·û´®Êý×éÖеÄλÖá£
        /// </summary>
        /// <param name="strSearch">´ýËÑË÷µÄ×Ö·û´®¡£</param>
        /// <param name="stringArray">×Ö·û´®Êý×é¡£</param>
        /// <param name="caseInsensetive">ÊÇ·ñ²»Çø·Ö´óСд, trueΪ²»Çø·Ö, falseΪÇø·Ö¡£</param>
        /// <returns>×Ö·û´®ÔÚÖ¸¶¨×Ö·û´®Êý×éÖеÄλÖÃ, Èç²»´æÔÚÔò·µ»Ø-1¡£</returns>
        public static int GetIndexInArray(string strSearch, string[] stringArray, bool caseInsensetive)
        {
            for (int i = 0; i < stringArray.Length; i++)
            {
                if (caseInsensetive)
                {
                    if (strSearch.ToLower() == stringArray[i].ToLower())
                    {
                        return i;
                    }
                }
                else
                {
                    if (strSearch == stringArray[i])
                    {
                        return i;
                    }
                }

            }
            return -1;
        }


        /// <summary>
        /// ÅжÏÖ¸¶¨×Ö·û´®ÔÚÖ¸¶¨×Ö·û´®Êý×éÖеÄλÖá£
        /// </summary>
        /// <param name="strSearch">×Ö·û´®¡£</param>
        /// <param name="stringArray">×Ö·û´®Êý×é¡£</param>
        /// <returns>×Ö·û´®ÔÚÖ¸¶¨×Ö·û´®Êý×éÖеÄλÖÃ, Èç²»´æÔÚÔò·µ»Ø-1¡£</returns>		
        public static int GetIndexInArray(string strSearch, string[] stringArray)
        {
            return GetIndexInArray(strSearch, stringArray, true);
        }

        /// <summary>
        /// ÅжÏÖ¸¶¨×Ö·û´®ÊÇ·ñÊôÓÚÖ¸¶¨×Ö·û´®Êý×éÖеÄÒ»¸öÔªËØ¡£
        /// </summary>
        /// <param name="strSearch">´ýËÑË÷µÄ×Ö·û´®¡£</param>
        /// <param name="stringArray">×Ö·û´®Êý×é¡£</param>
        /// <param name="caseInsensetive">ÊÇ·ñ²»Çø·Ö´óСд, trueΪ²»Çø·Ö, falseΪÇø·Ö¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsInArray(string strSearch, string[] stringArray, bool caseInsensetive)
        {
            return GetIndexInArray(strSearch, stringArray, caseInsensetive) >= 0;
        }

        /// <summary>
        /// ÅжÏÖ¸¶¨×Ö·û´®ÊÇ·ñÊôÓÚÖ¸¶¨×Ö·û´®Êý×éÖеÄÒ»¸öÔªËØ¡£
        /// </summary>
        /// <param name="str">´ýËÑË÷µÄ×Ö·û´®¡£</param>
        /// <param name="stringArray">×Ö·û´®Êý×é¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsInArray(string str, string[] stringArray)
        {
            return IsInArray(str, stringArray, false);
        }

        /// <summary>
        /// ÅжÏÖ¸¶¨×Ö·û´®ÊÇ·ñÊôÓÚÖ¸¶¨×Ö·û´®Êý×éÖеÄÒ»¸öÔªËØ¡£
        /// </summary>
        /// <param name="str">´ýËÑË÷µÄ×Ö·û´®¡£</param>
        /// <param name="stringArray">ÄÚ²¿ÒԷֺŷָ´ÊµÄ×Ö·û´®¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsInArray(string str, string stringArray)
        {
            return IsInArray(str, SafeSplitString(stringArray, ";"), false);
        }

        /// <summary>
        /// ÅжÏÖ¸¶¨×Ö·û´®ÊÇ·ñÊôÓÚÖ¸¶¨×Ö·û´®Êý×éÖеÄÒ»¸öÔªËØ¡£
        /// </summary>
        /// <param name="str">´ýËÑË÷µÄ×Ö·û´®</param>
        /// <param name="stringArray">ÄÚ²¿ÒÔÖ¸¶¨·Ö¸î·û·Ö¸îµ¥´ÊµÄ×Ö·û´®¡£</param>
        /// <param name="stringSplit">·Ö¸î×Ö·û´®¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsInArray(string str, string stringArray, string stringSplit)
        {
            return IsInArray(str, SafeSplitString(stringArray, stringSplit), false);
        }

        /// <summary>
        /// ÅжÏÖ¸¶¨×Ö·û´®ÊÇ·ñÊôÓÚÖ¸¶¨×Ö·û´®Êý×éÖеÄÒ»¸öÔªËØ¡£
        /// </summary>
        /// <param name="str">´ýËÑË÷µÄ×Ö·û´®</param>
        /// <param name="stringArray">ÄÚ²¿ÒÔÖ¸¶¨·Ö¸î·û·Ö¸îµ¥´ÊµÄ×Ö·û´®¡£</param>
        /// <param name="stringSplit">·Ö¸î×Ö·û´®¡£</param>
        /// <param name="caseInsensetive">ÊÇ·ñ²»Çø·Ö´óСд, trueΪ²»Çø·Ö, falseΪÇø·Ö¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsInArray(string str, string stringArray, string stringSplit, bool caseInsensetive)
        {
            return IsInArray(str, SafeSplitString(stringArray, stringSplit), caseInsensetive);
        }


        /// <summary>
        /// ɾ³ý×Ö·û´®Î²²¿µÄ»Ø³µ/»»ÐÐ/¿Õ¸ñ·ûºÅ¡£
        /// </summary>
        /// <param name="str">´ý´¦ÀíµÄ×Ö·û´®¡£</param>
        /// <returns>´¦ÀíºóµÄ×Ö·û´®¡£</returns>
        public static string RTrim(string str)
        {
            for (int i = str.Length; i >= 0; i--)
            {
                if (str[i].Equals(" ") || str[i].Equals("\r") || str[i].Equals("\n"))
                {
                    str.Remove(i, 1);
                }
            }
            return str;
        }


        /// <summary>
        /// Çå³ý¸ø¶¨×Ö·û´®ÖеĻسµ¼°»»Ðзû¡£
        /// </summary>
        /// <param name="str">ÒªÇå³ýµÄ×Ö·û´®¡£</param>
        /// <returns>´¦ÀíºóµÄ×Ö·û´®¡£</returns>
        public static string SafeClearBR(string str)
        {
            Match m = null;

            for (m = RegexBr.Match(str); m.Success; m = m.NextMatch())
            {
                str = str.Replace(m.Groups[0].ToString(), "");
            }

            return str;
        }

        /// <summary>
        /// ´Ó×Ö·û´®µÄÖ¸¶¨Î»ÖýØÈ¡Ö¸¶¨³¤¶ÈµÄ×Ó×Ö·û´®¡£
        /// </summary>
        /// <param name="str">Ô­×Ö·û´®¡£</param>
        /// <param name="startIndex">×Ó×Ö·û´®µÄÆðʼλÖá£</param>
        /// <param name="length">×Ó×Ö·û´®µÄ³¤¶È¡£</param>
        /// <returns>×Ó×Ö·û´®¡£</returns>
        public static string SafeCutString(string str, int startIndex, int length)
        {
            if (startIndex >= 0)
            {
                if (length < 0)
                {
                    length = length * -1;
                    if (startIndex - length < 0)
                    {
                        length = startIndex;
                        startIndex = 0;
                    }
                    else
                    {
                        startIndex = startIndex - length;
                    }
                }


                if (startIndex > str.Length)
                {
                    return "";
                }


            }
            else
            {
                if (length < 0)
                {
                    return "";
                }
                else
                {
                    if (length + startIndex > 0)
                    {
                        length = length + startIndex;
                        startIndex = 0;
                    }
                    else
                    {
                        return "";
                    }
                }
            }

            if (str.Length - startIndex < length)
            {
                length = str.Length - startIndex;
            }

            return str.Substring(startIndex, length);
        }

        /// <summary>
        /// ´Ó×Ö·û´®µÄÖ¸¶¨Î»ÖÿªÊ¼½ØÈ¡µ½×Ö·û´®½áβµÄÁË·û´®¡£
        /// </summary>
        /// <param name="str">Ô­×Ö·û´®¡£</param>
        /// <param name="startIndex">×Ó×Ö·û´®µÄÆðʼλÖá£</param>
        /// <returns>×Ó×Ö·û´®¡£</returns>
        public static string SafeCutString(string str, int startIndex)
        {
            return SafeCutString(str, startIndex, str.Length);
        }


        /// <summary>
        /// intÐÍת»»ÎªstringÐÍ¡£
        /// </summary>
        /// <returns>ת»»ºóµÄstringÀàÐͽá¹û¡£</returns>
        public static string FromInt(int intValue)
        {
            //
            return Convert.ToString(intValue);
        }


        /// <summary>
        /// È¡Ö¸¶¨³¤¶ÈµÄ×Ö·û´®£¬²¢ÔÚ½Øȡʱ¿¼ÂÇË«Óï×Ö·û£¬µ±×Ö·û´®Èç¹û²Ù¹ýÖ¸¶¨³¤¶ÈÔò½«³¬³öµÄ²¿·ÖÓÃÖ¸¶¨×Ö·û´®´úÌæ¡£
        /// </summary>
        /// <param name="srcString">Òª¼ì²éµÄ×Ö·û´®¡£</param>
        /// <param name="length">Ö¸¶¨³¤¶È¡£</param>
        /// <param name="tailString">ÓÃÓÚÌæ»»µÄ×Ö·û´®¡£</param>
        /// <returns>½ØÈ¡ºóµÄ×Ö·û´®¡£</returns>
        public static string GetSubString(string srcString, int length, string tailString)
        {
            return GetSubString(srcString, 0, length, tailString);
        }


        /// <summary>
        /// È¡Ö¸¶¨³¤¶ÈµÄ×Ö·û´®£¬²¢ÔÚ½Øȡʱ¿¼ÂÇË«Óï×Ö·û£¬µ±×Ö·û´®Èç¹û²Ù¹ýÖ¸¶¨³¤¶ÈÔò½«³¬³öµÄ²¿·ÖÓÃÖ¸¶¨×Ö·û´®´úÌæ¡£
        /// </summary>
        /// <param name="srcString">Òª¼ì²éµÄ×Ö·û´®¡£</param>
        /// <param name="startIndex">ÆðʼλÖá£</param>
        /// <param name="length">Ö¸¶¨³¤¶È¡£</param>
        /// <param name="tailString">ÓÃÓÚÌæ»»µÄ×Ö·û´®¡£</param>
        /// <returns>½ØÈ¡ºóµÄ×Ö·û´®¡£</returns>
        public static string GetSubString(string srcString, int startIndex, int length, string tailString)
        {


            string myResult = srcString;

            //µ±ÊÇÈÕÎÄ»òº«ÎÄʱ(×¢:ÖÐÎĵķ¶Î§:\u4e00 - \u9fa5, ÈÕÎÄÔÚ\u0800 - \u4e00, º«ÎÄΪ\xAC00-\xD7A3)
            if (System.Text.RegularExpressions.Regex.IsMatch(srcString, "[\u0800-\u4e00]+") ||
                System.Text.RegularExpressions.Regex.IsMatch(srcString, "[\xAC00-\xD7A3]+"))
            {
                //µ±½ØÈ¡µÄÆðʼλÖó¬³ö×ֶδ®³¤¶Èʱ
                if (startIndex >= srcString.Length)
                {
                    return "";
                }
                else
                {
                    return srcString.Substring(startIndex,
                                                   ((length + startIndex) > srcString.Length) ? (srcString.Length - startIndex) : length);
                }
            }


            if (length >= 0)
            {
                byte[] bsSrcString = Encoding.Default.GetBytes(srcString);

                //µ±×Ö·û´®³¤¶È´óÓÚÆðʼλÖÃ
                if (bsSrcString.Length > startIndex)
                {
                    int endIndex = bsSrcString.Length;

                    //µ±Òª½ØÈ¡µÄ³¤¶ÈÔÚ×Ö·û´®µÄÓÐЧ³¤¶È·¶Î§ÄÚ
                    if (bsSrcString.Length > (startIndex + length))
                    {
                        endIndex = length + startIndex;
                    }
                    else
                    {   //µ±²»ÔÚÓÐЧ·¶Î§ÄÚʱ,ֻȡµ½×Ö·û´®µÄ½áβ

                        length = bsSrcString.Length - startIndex;
                        tailString = "";
                    }



                    int nRealLength = length;
                    int[] anResultFlag = new int[length];
                    byte[] bsResult = null;

                    int nFlag = 0;
                    for (int i = startIndex; i < endIndex; i++)
                    {

                        if (bsSrcString[i] > 127)
                        {
                            nFlag++;
                            if (nFlag == 3)
                            {
                                nFlag = 1;
                            }
                        }
                        else
                        {
                            nFlag = 0;
                        }

                        anResultFlag[i] = nFlag;
                    }

                    if ((bsSrcString[endIndex - 1] > 127) && (anResultFlag[length - 1] == 1))
                    {
                        nRealLength = length + 1;
                    }

                    bsResult = new byte[nRealLength];

                    Array.Copy(bsSrcString, startIndex, bsResult, 0, nRealLength);

                    myResult = Encoding.Default.GetString(bsResult);

                    myResult = myResult + tailString;
                }
            }

            return myResult;
        }

        /// <summary>
        /// ×Ô¶¨ÒåµÄÌæ»»×Ö·û´®º¯Êý¡£
        /// </summary>
        /// <param name="sourceString">Ô´×Ö·û´®¡£</param>
        /// <param name="searchString">´ýÌæ»»µÄ×Ö·û´®</param>
        /// <param name="replaceString">Ìæ»»ºóµÄ×Ö·û´®</param>
        /// <param name="caseInsensetive">ÊÇ·ñ²»Çø·Ö´óСд, trueΪ²»Çø·Ö, falseΪÇø·Ö¡£</param>
        /// <returns>´¦ÀíºóµÄ×Ö·û´®¡£</returns>
        public static string SafeReplaceString(string sourceString, string searchString, string replaceString, bool caseInsensetive)
        {
            return Regex.Replace(sourceString, Regex.Escape(searchString), replaceString, caseInsensetive ? RegexOptions.IgnoreCase : RegexOptions.None);
        }

        /// <summary>
        /// ¼ì²âÊÇ·ñ·ûºÏemailµØÖ·¸ñʽ¡£
        /// </summary>
        /// <param name="strEmail">ÒªÅжϵÄemail×Ö·û´®¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsValidEmail(string strEmail)
        {
            return Regex.IsMatch(strEmail, @"^([\w-\.]+)@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$");
        }

        /// <summary>
        /// ¼ì²âÊÇ·ñ·ûºÏemailÖ·ÖÐÓòÃû¸ñʽ¡£
        /// </summary>
        /// <param name="strEmail">ÒªÅжϵÄemail×Ö·û´®¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsValidEmailDomain(string strEmail)
        {
            return Regex.IsMatch(strEmail, @"^@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([\w-]+\.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$");
        }

        /// <summary>
        /// ¼ì²âÊÇ·ñ·ûºÏUrl¸ñʽ¡£
        /// </summary>
        /// <param name="strUrl">ÒªÅжϵÄUrl¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsUrl(string strUrl)
        {
            return Regex.IsMatch(strUrl, @"^(http|https)\://([a-zA-Z0-9\.\-]+(\:[a-zA-Z0-9\.&%\$\-]+)*@)*((25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9])\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[0-9])|localhost|([a-zA-Z0-9\-]+\.)*[a-zA-Z0-9\-]+\.(com|edu|gov|int|mil|net|org|biz|arpa|info|name|pro|aero|coop|museum|[a-zA-Z]{1,10}))(\:[0-9]+)*(/($|[a-zA-Z0-9\.\,\?\'\\\+&%\$#\=~_\-]+))*$");
        }


        /// <summary>
        /// ¼ì²âÊÇ·ñΪbase64×Ö·û´®¡£
        /// </summary>
        /// <param name="str">ÒªÅжϵÄ×Ö·û´®¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsBase64String(string str)
        {
            //A-Z, a-z, 0-9, +, /, =
            return Regex.IsMatch(str, @"[A-Za-z0-9\+\/\=]");
        }

        /// <summary>
        /// ¼ì²âÊÇ·ñÓÐSqlΣÏÕ×Ö·û¡£
        /// </summary>
        /// <param name="str">ÒªÅжÏ×Ö·û´®¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsSafeSqlString(string str)
        {

            return !Regex.IsMatch(str, @"[-|;|,|\/|\(|\)|\[|\]|\}|\{|%|@|\*|!|\']");
        }

        /// <summary>
        /// ¼ì²âÊÇ·ñÓÐΣÏյĿÉÄÜÓÃÓÚÁ´½ÓµÄ×Ö·û´®¡£
        /// </summary>
        /// <param name="str">ÒªÅжÏ×Ö·û´®¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsSafeUserInfoString(string str)
        {
            return !Regex.IsMatch(str, @"^\s*$|^c:\\con\\con$|[%,\*" + "\"" + @"\s\t\<\>\&]|ÓοÍ|^Guest");
        }

        /// <summary>
        /// ÇåÀí×Ö·û´®¡£
        /// </summary>
        /// <param name="input">ÊäÈëµÄ×Ö·û´®¡£</param>
        /// <returns>´¦Àí½á¹û</returns>
        public static string SafeCleanInput(string input)
        {
            return Regex.Replace(input.Trim(), @"[^\w\.@-]", "");
        }

        /// <summary>
        /// ¼ì²âÊÇ·ñΪʱ¼ä×Ö·û´®¡£
        /// </summary>
        /// <param name="str">´ýÅжϵÄʱ¼ä×Ö·û´®¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsTime(string str)
        {
            return Regex.IsMatch(str, @"^((([0-1]?[0-9])|(2[0-3])):([0-5]?[0-9])(:[0-5]?[0-9])?)$");
        }


        /*
        /// <summary>
        /// ½«×Ö·û´®×ª»»Îª¼òÌåÖÐÎÄ¡£
        /// (([^"']|^)\[xui:+\w+\.+\w+\.+\w+\])+(\.+\w*)+(\[\d\])?
        /// [xui:form1.bysv.ss].value[102]=="[xui:form1.bysv.ss]" and [xui:form2.bysv.ss].value==c or [ps:0.1]==d
        /// </summary>
        /// <param name="str">´ýת»»µÄ×Ö·û´®¡£</param>
        /// <returns>ת»»½á¹û¡£</returns>
        public static string ToSimplifiedChinese(string str)
        {
            return Strings.StrConv(str, VbStrConv.SimplifiedChinese, 0);
        }

        /// <summary>
        /// ½«×Ö·û´®×ª»»Îª·±ÌåÖÐÎÄ¡£
        /// </summary>
        /// <param name="str">´ýת»»µÄ×Ö·û´®¡£</param>
        /// <returns>ת»»½á¹û¡£</returns>
        public static string ToTChinese(string str)
        {
            return Strings.StrConv(str, VbStrConv.TraditionalChinese, 0);
        }
         * */

        /// <summary>
        /// ·Ö¸î×Ö·û´®¡£
        /// </summary>
        /// <param name="srcString">´ý·Ö¸îµÄÔ´×Ö·û´®¡£</param>
        /// <param name="stringSplit">·Ö¸î·û¡£</param>
        /// <returns>·Ö¸îºóµÄ×Ö·û´®Êý×é¡£</returns>
        public static string[] SafeSplitString(string srcString, string stringSplit)
        {
            if (srcString.IndexOf(stringSplit) < 0)
            {
                string[] tmp = { srcString };
                return tmp;
            }
            return Regex.Split(srcString, Regex.Escape(stringSplit), RegexOptions.IgnoreCase);
        }

        /// <summary>
        /// ·Ö¸î×Ö·û´®¡£
        /// </summary>
        /// <param name="srcString">´ý·Ö¸îµÄÔ´×Ö·û´®¡£</param>
        /// <param name="stringSplit">·Ö¸î·û¡£</param>
        /// <param name="length">·µ»Ø×Ö·û´®Êý¾ÝµÄ³¤¶È£¬Èç¹û²»×ãÔòÒÔ¿Õ×Ö·û´®Ìî³ä¡£</param>
        /// <returns>·Ö¸îºóµÄ×Ö·û´®Êý×é¡£</returns>
        public static string[] SafeSplitString(string srcString, string stringSplit, int length)
        {
            string[] result = new string[length];

            string[] splited = SafeSplitString(srcString, stringSplit);

            for (int i = 0; i < length; i++)
            {
                if (i < splited.Length)
                    result[i] = splited[i];
                else
                    result[i] = string.Empty;
            }

            return result;
        }

        /// <summary>
        /// ʹÓÃÕýÔò±í´ïʽƥÅä×Ö·û´®£¬ÕÒ³öÿ¸ö·ûºÏÌõ¼þµÄµÚÒ»×éÊý¾Ý¡£
        /// </summary>
        /// <param name="regx"></param>
        /// <param name="source"></param>
        /// <returns></returns>
        /// <remarks>ͨ³£ÓÃÓÚÌæ»»±í´ïʽÖеÄÌØÊâ±ê¼Ç¡£</remarks>
        public static string[] SafeMatchString(string regx, string source)
        {
            Regex r = new Regex(regx, RegexOptions.IgnoreCase);
            Match m = r.Match(source);
            List<string> s = new List<string>();
            while (m.Success)
            {
                s.Add(m.Groups[1].Value);
                m = m.NextMatch();
            }

           
            return s.ToArray();
        }

        /// <summary>
        /// ½øÐÐÖ¸¶¨µÄÌæ»»(Ôà×Ö¹ýÂË)¡£
        /// </summary>
        /// <param name="str">´ý´¦ÀíµÄ×Ö·û´®¡£</param>
        /// <param name="bantext">´ý¹ýÂ˵Ä×Ö·û´®£¨Ôà×Ö£©¡£</param>
        /// <returns>´¦Àí½á¹û¡£</returns>
        public static string Filter(string str, string bantext)
        {
            string text1 = "";
            string text2 = "";
            string[] textArray1 = SafeSplitString(bantext, "\r\n");
            for (int num1 = 0; num1 < textArray1.Length; num1++)
            {
                text1 = textArray1[num1].Substring(0, textArray1[num1].IndexOf("="));
                text2 = textArray1[num1].Substring(textArray1[num1].IndexOf("=") + 1);
                str = str.Replace(text1, text2);
            }
            return str;
        }


        /// <summary>
        /// ¼ÆËã×Ö½ÚÊý´óС²¢·µ»Ø×îÆ¥Å䵥λµÄÏàÓ¦µÄ×Ö·û´®¡£
        /// </summary>
        /// <param name="size">×Ö½Ú´óС¡£</param>
        /// <returns>×îÆ¥Å䵥λµÄÏàÓ¦µÄ×Ö·û´®¡£</returns>
        public static string FormatBytesString(int size)
        {
            if (size > 1073741824)
            {
                return ((double)(size / 1073741824)).ToString("0") + "G";
            }
            if (size > 1048576)
            {
                return ((double)(size / 1048576)).ToString("0") + "M";
            }
            if (size > 1024)
            {
                return ((double)(size / 1024)).ToString("0") + "K";
            }
            return size.ToString() + "Bytes";
        }


        /// <summary>
        /// ¼ì²âÊÇ·ñ·ûºÏIPµØÖ·¸ñʽ(IPv4)¡£
        /// </summary>
        /// <param name="strIp">ÒªÅжϵÄIP×Ö·û´®¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsIP(string strIp)
        {
            return Regex.IsMatch(strIp, @"^((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)$");

        }


        /// <summary>
        /// ¼ì²âÊÇ·ñÊÇIPµØÖ·¶Î(IPv4)¡£
        /// </summary>
        /// <param name="strIp">ÒªÅжϵÄIP×Ö·û´®¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsIPSect(string strIp)
        {
            return Regex.IsMatch(strIp, @"^((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){2}((2[0-4]\d|25[0-5]|[01]?\d\d?|\*)\.)(2[0-4]\d|25[0-5]|[01]?\d\d?|\*)$");

        }


        /// <summary>
        /// ½«È«½ÇÊý×Öת»»ÎªÊý×Ö¡£
        /// </summary>
        /// <param name="SBCCase">È«½ÇÊý×Ö¡£</param>
        /// <returns>´¦Àí½á¹û¡£</returns>
        public static string SBCCaseToNumberic(string SBCCase)
        {
            char[] c = SBCCase.ToCharArray();
            for (int i = 0; i < c.Length; i++)
            {
                byte[] b = System.Text.Encoding.Unicode.GetBytes(c, i, 1);
                if (b.Length == 2)
                {
                    if (b[1] == 255)
                    {
                        b[0] = (byte)(b[0] + 32);
                        b[1] = 0;
                        c[i] = System.Text.Encoding.Unicode.GetChars(b)[0];
                    }
                }
            }
            return new string(c);
        }


        /// <summary>
        /// ɾ³ý×îºóÒ»¸ö×Ö·û¡£
        /// </summary>
        /// <param name="str">´ý´¦ÀíµÄ×Ö·û´®¡£</param>
        /// <returns>´¦Àí½á¹û¡£</returns>
        public static string SafeClearLastChar(string str)
        {
            if (str == "")
                return "";
            else
                return str.Substring(0, str.Length - 1);
        }

        /// <summary>
        /// ½«×Ö·û´®×ª»»ÎªColor¡£
        /// </summary>
        /// <param name="color">ÑÕÉ«×Ö·û´®£¬ÑÕÉ«¿ÉÒÔÊÇÑÕÉ«Ãû£¬Ò²¿ÉÒÔÊÇRGBÖµ»ò±ê×¼ÑÕÉ«Öµ¡£</param>
        /// <returns>´¦Àí½á¹û¡£</returns>
        public static Color ToColor(string color)
        {
            int red, green, blue = 0;
            char[] rgb;
            color = color.TrimStart('#');
            color = Regex.Replace(color.ToLower(), "[g-zG-Z]", "");
            switch (color.Length)
            {
                case 3:
                    rgb = color.ToCharArray();
                    red = Convert.ToInt32(rgb[0].ToString() + rgb[0].ToString(), 16);
                    green = Convert.ToInt32(rgb[1].ToString() + rgb[1].ToString(), 16);
                    blue = Convert.ToInt32(rgb[2].ToString() + rgb[2].ToString(), 16);
                    return Color.FromArgb(red, green, blue);
                case 6:
                    rgb = color.ToCharArray();
                    red = Convert.ToInt32(rgb[0].ToString() + rgb[1].ToString(), 16);
                    green = Convert.ToInt32(rgb[2].ToString() + rgb[3].ToString(), 16);
                    blue = Convert.ToInt32(rgb[4].ToString() + rgb[5].ToString(), 16);
                    return Color.FromArgb(red, green, blue);
                default:
                    return Color.FromName(color);

            }
        }

        /// <summary>
        /// ¼ì²â×Ö·û´®ÊÇ·ñÊÇÈÕÆÚ×Ö·û´®¡£
        /// </summary>
        /// <param name="str">´ýÅжÏ×Ö·û´®¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsDateString(string str)
        {
            return Regex.IsMatch(str, @"(\d{4})-(\d{1,2})-(\d{1,2})");
        }

        /// <summary>
        /// ¼ì²âÊÇ·ñΪÕýÕûÊý¡£
        /// </summary>
        /// <param name="str">´ýÅжÏ×Ö·û´®¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsPlusInt(string str)
        {

            return Regex.IsMatch(str, @"^[0-9]*$");
        }

        /// <summary>
        /// ¼ì²â¸ø¶¨µÄ×Ö·û´®Êý×é(strNumber)ÖеÄÊý¾ÝÊDz»ÊǶ¼ÎªÊýÖµÐÍ¡£
        /// </summary>
        /// <param name="strNumber">ҪȷÈϵÄ×Ö·û´®Êý×é¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsNumericArray(string[] strNumber)
        {
            if (strNumber == null)
            {
                return false;
            }
            if (strNumber.Length < 1)
            {
                return false;
            }
            foreach (string id in strNumber)
            {
                if (!IsNumeric(id))
                {
                    return false;
                }
            }
            return true;

        }

        /// <summary>
        /// ¼ì²â×Ö·û´®ÊÇ·ñΪInt32ÀàÐ͵ÄÊý×Ö¡£
        /// </summary>
        /// <param name="str">´ýÅжϵÄ×Ö·û´®¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsNumeric(string  str)
        {

            if (str.Length > 0 && str.Length <= 11 && Regex.IsMatch(str, @"^[-]?[0-9]*[.]?[0-9]*$"))
            {
                if ((str.Length < 10) || (str.Length == 10 && str[0] == '1') || (str.Length == 11 && str[0] == '-' && str[1] == '1'))
                {
                    return true;
                }
            }

            return false;

        }

        /// <summary>
        /// ¼ì²â×Ö·û´®ÊÇ·ñΪDoubleÀàÐ͵ÄÊý×Ö¡£
        /// </summary>
        /// <param name="str">´ýÅжϵÄ×Ö·û´®¡£</param>
        /// <returns>ÅжϽá¹û¡£</returns>
        public static bool IsDouble(string str)
        {
                return Regex.IsMatch(str, @"^([0-9])[0-9]*(\.\w*)?$");
        }

        /// <summary>
        /// stringÐÍת»»ÎªboolÐÍ¡£
        /// </summary>
        /// <param name="str">´ýת»»µÄ×Ö·û´®¡£</param>
        /// <param name="defaultValue">ȱʡֵ¡£</param>
        /// <returns>ת»»ºóµÄboolÀàÐͽá¹û¡£</returns>
        public static bool ToBool(string str, bool defaultValue)
        {
            if (str != null)
            {
                if (string.Compare(str, "true", true) == 0)
                {
                    return true;
                }
                else if (string.Compare(str, "false", true) == 0)
                {
                    return false;
                }
            }
            return defaultValue;
        }

        /// <summary>
        /// ½«×Ö·û´®×ª»»ÎªInt32ÀàÐÍ¡£
        /// </summary>
        /// <param name="str">´ýת»»µÄ×Ö·û´®¡£</param>
        /// <param name="defaultValue">ȱʡֵ¡£</param>
        /// <returns>ת»»ºóµÄintÀàÐͽá¹û¡£</returns>
        public static int ToInt(string  str, int defaultValue)
        {
            if (str != null)
            {
                if (str.Length > 0 && str.Length <= 11 && Regex.IsMatch(str, @"^[-]?[0-9]*$"))
                {
                    if ((str.Length < 10) || (str.Length == 10 && str[0] == '1') || (str.Length == 11 && str[0] == '-' && str[1] == '1'))
                    {
                        return Convert.ToInt32(str);
                    }
                }
            }
            return defaultValue;
        }

        /// <summary>
        /// stringÐÍת»»ÎªfloatÐÍ¡£
        /// </summary>
        /// <param name="str">´ýת»»µÄ×Ö·û´®¡£</param>
        /// <param name="defaultValue">ȱʡֵ¡£</param>
        /// <returns>ת»»ºóµÄintÀàÐͽá¹û¡£</returns>
        public static float ToFloat(string str, float defaultValue)
        {
            if ((str == null) || (str.Length > 10))
            {
                return defaultValue;
            }

            float intValue = defaultValue;
            if (str != null)
            {
                bool IsFloat = Regex.IsMatch(str.ToString(), @"^([-]|[0-9])[0-9]*(\.\w*)?$");
                if (IsFloat)
                {
                    intValue = Convert.ToSingle(str);
                }
            }
            return intValue;
        }


        /// <summary>
        /// ½«×Ö·û´®×ª»»ÎªInt32ÀàÐÍ
        /// </summary>
        /// <param name="str">´ýת»»µÄ×Ö·û´®¡£</param>
        /// <returns>ת»»ºóµÄInt32ÀàÐͽá¹û¡£</returns>
        public static int ToInt32(string  str)
        {
            if (str == null)
            {
                return 0;
            }
            string strNum = str;
            if (IsNumeric(strNum))
            {

                if (strNum.ToString().Length > 9)
                {
                    if (strNum.StartsWith("-"))
                    {
                        return int.MinValue;
                    }
                    else
                    {
                        return int.MaxValue;
                    }
                }
                return Int32.Parse(strNum);
            }
            else
            {
                return 0;
            }
        }

        /// <summary>
        /// ½«×Ö·û´®×ª»»ÎªBase64ÀàÐÍ
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static  string ToBase64String(string str)
        {
            byte[] data = System.Text.Encoding.Unicode.GetBytes(str);
            return Convert.ToBase64String(data);
        }

        /// <summary>
        /// FromBase64String
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static  string FromBase64String(string str)
        {
            byte[] data = Convert.FromBase64String(str);
            return System.Text.Encoding.Unicode.GetString(data);
        }

        /// <summary>
        /// ѹËõ×Ö·û´®
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string ToCompressionString(string str)
        {
            return str;
        }

        /// <summary>
        /// ½âѹ×Ö·û´®
        /// </summary>
        /// <param name="str"></param>
        /// <returns></returns>
        public static string FromCompressionString(string str)
        {
            return str;
        }

        /// <summary>
        /// °Ñ×Ö·û´®Êý¾Ýת»¯Îª×Ö·û
        /// </summary>
        /// <param name="array"></param>
        /// <param name="separator"></param>
        /// <returns></returns>
        public static string FromStringArray(string[] array, string separator)
        {
            string s = string.Empty;
            foreach (string t in array)
                s += separator + t;
            if (s.Length > separator.Length)
                s = s.Substring(separator.Length);

            return s;
        }

        /// <summary>
        /// ½«×Öµäת»»Îª×Ö·û´®±í´ïʽ¡£
        /// </summary>
        /// <param name="dic"></param>
        /// <returns></returns>
        public static string FromDictionary(Dictionary<string, string> dic)
        {
            if (dic.Count == 0)
                return string.Empty;

            string rstr = string.Empty;
            foreach (string key in dic.Keys)
            {
                rstr += ";" + key + "=" + dic[key];
            }

            if (rstr.Length > 1)
                rstr = rstr.Substring(1);
            return rstr;
        }

        /// <summary>
        /// ½«Êý×éת»»Îª×Ö·û´®±í´ïʽ¡£
        /// </summary>
        /// <param name="array"></param>
        /// <param name="dictionary">ÊÇ·ñת»¯Îª×ÖµäÑùʽ</param>
        /// <returns></returns>
        public static string FromArray(string[] array,bool dictionary)
        {
            if (array.Length == 0)
                return string.Empty;

            string rstr = string.Empty;
            foreach (string key in array)
            {
                if(dictionary)
                    rstr += ";" + key + "=" + key;
                else
                    rstr += ";" + key ;
            }

            if (rstr.Length > 1)
                rstr = rstr.Substring(1);
            return rstr;
        }

        /// <summary>
        /// ½«×Ö·û´®½âÎöΪ×ֵ䣬ҪÇó×Ö·û´®µÄ¸ñʽΪ:¼ü=Öµ;¼ü=Öµ
        /// </summary>
        /// <param name="str">×Ö·û´®¡£</param>
        /// <returns></returns>
        public static Dictionary<string, string> ToDictionary(string str)
        {
            Dictionary<string, string> dic = new Dictionary<string, string>();
            if (str == null || str == string.Empty)
                return dic;

            string[] items = str.Split(new char[1] { ';' });
            for (int i = 0; i <= items.Length - 1; i++)
            {
                if (!items[i].Contains("="))
                    continue;
                string[] item = items[i].Split(new char[1] { '=' });
                dic.Add(item[0], item[1]);
            }

            return dic;
        }

        /*
        public static string FromNamedValueCollection(NamedValueItemCollection dic)
        {
            if (dic.Count == 0)
                return string.Empty;

            string rstr = string.Empty;
            foreach (NamedValueItem item in dic)
            {
                rstr += ";" + item.Name + "=" + item.StringValue;
            }

            if (rstr.Length > 1)
                rstr = rstr.Substring(1);
            return rstr;
        }

        public static NamedValueItemCollection ToNamedValueCollection(string str)
        {
            NamedValueItemCollection dic = new  NamedValueItemCollection();
            if (str == null || str == string.Empty)
                return dic;

            string[] items = str.Split(new char[1] { ';' });
            for (int i = 0; i <= items.Length - 1; i++)
            {
                if (!items[i].Contains("="))
                    continue;
                string[] item = items[i].Split(new char[1] { '=' });
                dic.Add(item[0], item[1]);
            }

            return dic;
        }
        */
        /// <summary>
        /// ±í´ïʽֵ½»»»£¬¼´½«Öµ±í´ïʽÖеÄÖµ°´Ãû³ÆÌæ»»µ½Ô´±í´ïʽÖС£
        /// </summary>
        /// <param name="srcExpr">Ô´±í´ïʽ,¸ñʽΪ Ãû³Æ=Öµ±í´ïʽÃû³Æ£»Ãû³Æ=Öµ±í´ïʽÃû³Æ</param>
        /// <param name="valExpr">Öµ±í´ïʽ,¸ñʽΪֵ±í´ïʽÃû³Æ=Öµ;¸ñʽΪֵ±í´ïʽÃû³Æ=Öµ</param>
        /// <returns>·µ»Øºó±í´ïʽΪ Ãû³Æ=Öµ;Ãû³Æ=Öµ</returns>
        public static string ExpressionValueExchange(string srcExpr, string valExpr)
        {
            string rstr = string.Empty;
            string[] src = srcExpr.Split(new char[1] { ';' });
            string[] val = valExpr.Split(new char[1] { ';' });
            Dictionary<string, string> dval = new Dictionary<string, string>();
            for (int i = 0; i <= val.Length - 1; i++)
            {
                int p = val[i].IndexOf("=");
                dval.Add(val[i].Substring(0, p), val[i].Substring(p + 1));
            }

            for (int i = 0; i <= src.Length - 1; i++)
            {
                int p = src[i].IndexOf("=");
                string sn = src[i].Substring(0, p);
                string sv = src[i].Substring(p+1);

                if (dval.ContainsKey(sv))
                    sv = dval[sv];
                else
                    sv = string.Empty;

                if (rstr == string.Empty)
                    rstr = sn + "=" + sv;
                else
                    rstr = rstr+";"+sn + "=" + sv;
            }

            return rstr;
        }

        /// <summary>
        /// ¸ñʽ»¯×Ö·û´®¡£
        /// </summary>
        /// <param name="formatText">¸ñʽ»¯×Ö·û´®£¬Öм䲻ÄÜ°üÀ¨¶ººÅ¡£¸ñʽΪ£º¸ñʽ»¯×Ö·û´®,²ÎÊý×Ö¶ÎÃû1,,²ÎÊý×Ö¶ÎÃû2</param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public static  string FormatString(string formatText, DataRow parameters)
        {
            if (parameters == null)
                return formatText;

            string[] fsParts = formatText.Split(new char[1] { ',' });
            string[] fparas = new string[fsParts.Length - 1];
            for (int i = 1; i <= fsParts.Length - 1; i++)
            {
                if (parameters.Table.Columns.Contains(fsParts[i]))
                    fparas[i - 1] = parameters[fsParts[i]].ToString();
                else
                    fparas[i - 1] = string.Empty;
            }

            string s = string.Format(fsParts[0], fparas);
            return s;
        }

        /// <summary>
        /// »ñÈ¡·Ö¸ô×Ö·û´®Êý×é;È罫"[DBB004]=DAB004;[DBB005]=DAB005;[DBB006]=[DAB009]"·Ö¸ô×Ö·ûÊý×é:DBB004,DAB004,DBB005,DAB005,DBB006,DAB009
        /// </summary>
        /// <param name="strValue">Ó³Éä×Ö·û</param>
        /// <returns>×Ö·û´®Êý×é</returns>
        public static string[] GetSplitString(string strValue)
        {
            if (strValue == null)
                return null;
            if (strValue.Length == 0)
                return null;

            strValue = strValue.Replace("[", "").Replace("]", "");
            string[] strArray = strValue.Split(new char[2] { ';', '=' });
            return strArray;
        } 

        /// <summary>
        /// ¶ÔÎı¾,·Ö¸ôµÄ×Ö·û½øÐÐÌí¼Óµ¥ÒýºÅ,¶ÔÓÚÌõ¼þÊÇinµÄʱºò½øÐÐÌí¼Óµ¥ÒýºÅ
        /// x022,x023,x025===>'x022','x023','x025'
        /// </summary>
        /// <param name="strText">´«ÈëµÄ×Ö·û´®</param>
        /// <returns>·µ»ØÌí¼Óµ¥ÒýºÅµÄ×Ö·û</returns>
        public static string AddSingleQuote(string strText)
        {
            string[] value = strText.Split(new char[1] { ',' });
            for (int i = 0; i < value.Length; i++)
            {
                string para = value[i];
                if (para.StartsWith("'"))
                    para = para.Substring(1);
                if (para.EndsWith("'"))
                    para = para.Substring(0, para.Length - 1);
                value[i] = "'" + para + "'";
            }
            string str = string.Join(",", value);
            return str;
        }

        /// <summary>
        /// Gets the express string.
        /// </summary>
        /// <param name="strValue">The STR value.</param>
        /// <returns></returns>
        public static string[] GetExpressString(string strValue)
        {
            string[] strs = strValue.Split(new char[2] { '=', ' ' });
            List<string> strList = new List<string>();            
            foreach (string str in strs)
            {
                if (str.Contains("["))
                    strList.Add(str);
            }
            return strList.ToArray();
            //return strs.Where(c => c.Contains('[')).ToArray();
        }



        /// <summary>
        /// ¼ìÑéÁ½¸öÊý×ÖÊÇ·ñÏàµÈ
        /// </summary>
        /// <param name="x">µÚÒ»¸öÊý×Ö</param>
        /// <param name="y">µÚ¶þ¸öÊý×Ö</param>
        /// <returns>·µ»Øtrue£»false</returns>
        public static bool AboutEqual(double x, double y)
        {
            double epsilon = Math.Max(Math.Abs(x), Math.Abs(y)) * 1E-15;
            return Math.Abs(x - y) <= epsilon;
        }

        /// <summary>
        /// ¼ìÑéÊý×ÖÊý×éÊÇ·ñÈ«²¿ÏàµÈ
        /// ²ÉÓÃÏàµÈ´«µÝµÄ·½·¨£¬ÑéÖ¤Ò»ÂÖ¼´¿É
        /// </summary>
        /// <param name="douArrs"></param>
        /// <returns></returns>
        public static bool AboutEqual(params double[] douArrs)
        {
            double dbFirst = douArrs[0];
            for (int t = 1; t < douArrs.Length; t++)
            {
                if (!AboutEqual(dbFirst, douArrs[t]))
                    return false;
            }
            return true;
        }

        /// <summary>
        /// ×Ö·ûÊý×éÑéÖ¤ÊÇ·ñÓÐΪ¿Õ»òÕßnull
        /// </summary>
        /// <param name="objs"></param>
        /// <returns></returns>
        public static bool ExistsEmptyOrNull(params object[] objs)
        {
            if (objs == null || objs.Length == 0)
                return true;
            foreach (object obj in objs)
            {
                if (IsNullOrEmptyReturnZero<string>(obj) == "")
                    return true;
            }
            return false;
        }

        /// <summary>
        /// ·ºÐÍת»»ÎªÊýÖµÀàÐÍ
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="obj"></param>
        /// <returns></returns>
        public static T IsNullOrEmptyReturnZero<T>(object obj)
        {
            if (Equals(obj, null) || Equals(DBNull.Value, obj))
            {
                if (typeof(T).FullName == "System.String")
                    return (T)Convert.ChangeType("", typeof(T));
                return default(T);
            }
            try
            {
                return (T)Convert.ChangeType(obj, typeof(T));
            }
            catch
            {
                return default(T);
            }
        }


    }
}