~jt/AutoWMS.lanyueliang.git

ÿþusing System; 
using System.Collections.Generic; 
using System.Text; 
using System.Text.RegularExpressions; 
 
namespace HH.WMS.Utils 
{ 
    public partial class ZString 
    { 
        private static Regex RegexBr = new Regex(@"(\r\n)", RegexOptions.IgnoreCase); 
       // public static Regex RegexFont = new Regex(@"<font color=" + "\".*?\"" + @">([\s\S]+?)</font>", Utils.GetRegexCompiledOptions()); 
 
 
        /// <summary> 
        /// W[Ík'YQ 
        /// </summary> 
        /// <param name="str"></param> 
        /// <returns></returns> 
        public static string ToTitleCase(string str) 
        { 
            return System.Globalization.CultureInfo.CurrentCulture.TextInfo.ToTitleCase(str); 
        } 
 
        /// <summary> 
        /// ÔÞVW[&{2Nw[¦^, 1*NIlW[¦^:N2 
        /// </summary> 
        /// <returns></returns> 
        public static int GetStringLength(string str) 
        { 
            return Encoding.Default.GetBytes(str).Length; 
        } 
 
        /// <summary> 
        /// $Rec[W[&{2N(Wc[W[&{2NpeÄ~-NvMOn 
        /// </summary> 
        /// <param name="strSearch">W[&{2N</param> 
        /// <param name="stringArray">W[&{2NpeÄ~</param> 
        /// <param name="caseInsensetive">/f&T N:SR'Y\Q, true:N N:SR, false:N:SR</param> 
        /// <returns>W[&{2N(Wc[W[&{2NpeÄ~-NvMOn, Y NX[(WRÔÞV-1</returns> 
        public static int GetInArrayID(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> 
        ///  RdW[&{2N>\èvÞVf/bcL/zz<h 
        /// </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> 
        /// ndÙ~[W[&{2N-NvÞVfÊSbcL&{ 
        /// </summary> 
        /// <param name="str">ndvW[&{2N</param> 
        /// <returns>ndTÔÞVvW[&{2N</returns> 
        public static string ClearBR(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> 
        /// W[&{2NYgÍdÇc[¦^R\úQvèR(uc[W[&{2NãNÿf 
        /// </summary> 
        /// <param name="p_SrcString">ÀhågvW[&{2N</param> 
        /// <param name="p_Length">c[¦^</param> 
        /// <param name="p_TailString">(uNÿfbcvW[&{2N</param> 
        /// <returns>*bÖSTvW[&{2N</returns> 
        public static string GetSubString(string p_SrcString, int p_Length, string p_TailString) 
        { 
            return GetSubString(p_SrcString, 0, p_Length, p_TailString); 
        } 
 
 
        /// <summary> 
        /// ÖSc[¦^vW[&{2N 
        /// </summary> 
        /// <param name="p_SrcString">ÀhågvW[&{2N</param> 
        /// <param name="p_StartIndex">wËYMOn</param> 
        /// <param name="p_Length">c[¦^</param> 
        /// <param name="p_TailString">(uNÿfbcvW[&{2N</param> 
        /// <returns>*bÖSTvW[&{2N</returns> 
        public static string GetSubString(string p_SrcString, int p_StartIndex, int p_Length, string p_TailString) 
        { 
 
 
            string myResult = p_SrcString; 
 
            //S_/fåeebéeöe(èl:-NevôV:\u4e00 - \u9fa5, åee(W\u0800 - \u4e00, ée:N\xAC00-\xD7A3) 
            if (System.Text.RegularExpressions.Regex.IsMatch(p_SrcString, "[\u0800-\u4e00]+") || 
                System.Text.RegularExpressions.Regex.IsMatch(p_SrcString, "[\xAC00-\xD7A3]+")) 
            { 
                //S_*bÖSvwËYMOnúQW[µk2N¦^öe 
                if (p_StartIndex >= p_SrcString.Length) 
                { 
                    return ""; 
                } 
                else 
                { 
                    return p_SrcString.Substring(p_StartIndex, 
                                                   ((p_Length + p_StartIndex) > p_SrcString.Length) ? (p_SrcString.Length - p_StartIndex) : p_Length); 
                } 
            } 
 
 
            if (p_Length >= 0) 
            { 
                byte[] bsSrcString = Encoding.Default.GetBytes(p_SrcString); 
 
                //S_W[&{2N¦^'YNwËYMOn 
                if (bsSrcString.Length > p_StartIndex) 
                { 
                    int p_EndIndex = bsSrcString.Length; 
 
                    //S_*bÖSv¦^(WW[&{2Nv    gHe¦^ôVQ 
                    if (bsSrcString.Length > (p_StartIndex + p_Length)) 
                    { 
                        p_EndIndex = p_Length + p_StartIndex; 
                    } 
                    else 
                    {   //S_ N(W    gHeôVQöe,êSÖS0RW[&{2NvÓ~>\ 
 
                        p_Length = bsSrcString.Length - p_StartIndex; 
                        p_TailString = ""; 
                    } 
 
 
 
                    int nRealLength = p_Length; 
                    int[] anResultFlag = new int[p_Length]; 
                    byte[] bsResult = null; 
 
                    int nFlag = 0; 
                    for (int i = p_StartIndex; i < p_EndIndex; i++) 
                    { 
 
                        if (bsSrcString[i] > 127) 
                        { 
                            nFlag++; 
                            if (nFlag == 3) 
                            { 
                                nFlag = 1; 
                            } 
                        } 
                        else 
                        { 
                            nFlag = 0; 
                        } 
 
                        anResultFlag[i] = nFlag; 
                    } 
 
                    if ((bsSrcString[p_EndIndex - 1] > 127) && (anResultFlag[p_Length - 1] == 1)) 
                    { 
                        nRealLength = p_Length + 1; 
                    } 
 
                    bsResult = new byte[nRealLength]; 
 
                    Array.Copy(bsSrcString, p_StartIndex, bsResult, 0, nRealLength); 
 
                    myResult = Encoding.Default.GetString(bsResult); 
 
                    myResult = myResult + p_TailString; 
                } 
            } 
 
            return myResult; 
        } 
 
 
        /// <summary> 
        /// ê[INvÿfbcW[&{2NýQpe 
        /// </summary> 
        public static string ReplaceString(string SourceString, string SearchString, string ReplaceString, bool IsCaseInsensetive) 
        { 
            return Regex.Replace(SourceString, Regex.Escape(SearchString), ReplaceString, IsCaseInsensetive ? RegexOptions.IgnoreCase : RegexOptions.None); 
        } 
 
 
        
 
        /// <summary> 
        /// RrRW[&{2N 
        /// </summary> 
        public static string[] SplitString(string strContent, string strSplit) 
        { 
            if (strContent.IndexOf(strSplit) < 0) 
            { 
                string[] tmp = { strContent }; 
                return tmp; 
            } 
            return Regex.Split(strContent, Regex.Escape(strSplit), RegexOptions.IgnoreCase); 
        } 
 
        /// <summary> 
        /// RrRW[&{2N 
        /// </summary> 
        /// <param name="strContent">_RrRW[&{2N</param> 
        /// <param name="strSplit">R&{</param> 
        /// <param name="p_3">c[RrRpeÄ~'Y\</param> 
        /// <returns>string[]</returns> 
        public static string[] SplitString(string strContent, string strSplit, int p_3) 
        { 
            string[] result = new string[p_3]; 
 
            string[] splited = SplitString(strContent, strSplit); 
 
            for (int i = 0; i < p_3; i++) 
            { 
                if (i < splited.Length) 
                    result[i] = splited[i]; 
                else 
                    result[i] = string.Empty; 
            } 
 
            return result; 
        } 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
    } 
}