一个项目中使用到的通用函数库(2) 字符操作

 

#region  字符操作
        /// <summary>
        /// 文本调试模版
        /// </summary>
        public const string Text_DebugTemplate = "<div align="center"><div style="Background-color:#f3f3f3;color:#000000;width:75%;height:120px;font-family:'Times New Roman';font-size:14px;border:1px #cccccc dotted;padding:5px;">" +
            "<fieldset style="height:100%"><legend>===========调试信息==============</legend>" +
            "<div align="left"  style="text-indent:24px;font-family:fixedsys;font-size:12px;color:red;word-break:break-all;line-height:150%;padding-left:32px;padding-right:32px;">[信息内容]</div>" +
            "</fieldset></div></div>";

        #region 编码和格式转化
        /// <summary>
        /// 从一种编码到另一种编码
        /// </summary>
        /// <param name="str">源字符串</param>
        /// <param name="From">From</param>
        /// <param name="To">To</param>
        /// <returns></returns>
        string ConertStr(string str, string From, string To)
        {

            byte[] bs = System.Text.Encoding.GetEncoding(From).GetBytes(str);
            bs = System.Text.Encoding.Convert(System.Text.Encoding.GetEncoding(From), System.Text.Encoding.GetEncoding(To), bs);
            string res = System.Text.Encoding.GetEncoding(To).GetString(bs);
            return res;

        }

        /// <summary>
        /// 获取能够在客户端显示的XML文本内容
        /// </summary>
        /// <param name="OStr">文本内容</param>
        /// <returns>合格的XML文本内容</returns>
        public static string Text_GetXMLString(string OStr)
        {
            return OStr.Replace("'", "＇").Replace(">", "&gt;").Replace("<", "&lt;").Replace("&", "&amp;");
        }

        /// <summary>
        /// 获取能够在客户端显示的Javascript文本内容
        /// </summary>
        /// <param name="OStr">文本内容</param>
        /// <returns>合格的Javascript文本内容</returns>
        public static string Text_GetJsString(string OStr)
        {
            return OStr.Replace("'", "/'").Replace(""", "/" + """).Replace(" ", "/" + "n").Replace(" ", "/" + "r").Replace(" ", "/" + "n" + "/" + "r");
        }

        /// <summary>
        /// 普通文本转换为HTML文本
        /// </summary>
        /// <param name="sText">普通文本内容</param>
        /// <returns>HTML格式文本</returns>
        public static string Text_Plain2Html(string sText)
        {
            string rStr = string.Empty;
            if (sText.Length > 0)
            {
                rStr = sText.Replace(" ", "<br>").Replace(" ", "<br>").Replace(" ", "<br>").Replace(" ", "&nbsp;");
            }
            else
            {
                rStr = "";
            }
            return rStr;

        }

        /// <summary>
        /// 数组转换为普通字符
        /// </summary>
        /// <param name="StringArray">字符数组</param>
        /// <param name="Sperator">字符分隔符</param>
        /// <returns>该数组的字符串表现形式</returns>
        public static string Text_ArrayToString(string[] StringArray, string Sperator)
        {
            int Len = StringArray.Length;
            string ReturnString = String.Empty;
            for (int i = 0; i < Len; i++)
            {
                ReturnString += (i > 0) ? (Sperator + StringArray[i]) : (StringArray[i]);
            }
            return ReturnString;
        }


        /// <summary>
        /// 数组转换为普通字符
        /// </summary>
        /// <param name="IntArrayArray">整形数组</param>
        /// <param name="Sperator">字符分隔符</param>
        /// <returns>该数组的字符串表现形式</returns>
        public static string Text_ArrayToString(int[] IntArray, string Sperator)
        {
            int Len = IntArray.Length;
            string ReturnString = String.Empty;
            for (int i = 0; i < Len; i++)
            {
                ReturnString += (i > 0) ? (Sperator + IntArray[i].ToString()) : (IntArray[i].ToString());
            }
            return ReturnString;
        }

        /// <summary>
        /// 返回字符的ASCII值
        /// </summary>
        /// <param name="String">字符</param>
        /// <returns>该字符的ASCII</returns>
        public static int Text_Asc(char __String)
        {
            int num1;
            int num2;
            byte[] array1;
            char[] array2;
            Encoding encoding1;
            int num3;
            byte num4;
            char[] array3;


            num2 = Convert.ToInt32(__String);
            if (num2 < 128)
            {
                return num2;
            }
            try
            {
                encoding1 = Encoding.Default;//------当前代码页
                array3 = new char[1];
                array3[0] = __String;
                array2 = array3;

                if (encoding1.GetMaxByteCount(1) == 1)
                {
                    array1 = new byte[1];
                    num3 = encoding1.GetBytes(array2, 0, 1, array1, 0);
                    num1 = array1[0];
                    return num1;

                }
                array1 = new byte[2];
                num3 = encoding1.GetBytes(array2, 0, 1, array1, 0);
                if (num3 == 1)
                {
                    num1 = array1[0];
                    return num1;

                }
                if (BitConverter.IsLittleEndian)
                {
                    num4 = array1[0];
                    array1[0] = array1[1];
                    array1[1] = num4;

                }
                num1 = BitConverter.ToInt16(array1, 0);

            }
            catch (Exception exception1)
            {
                throw exception1;

            }
            return num1;
        }

        /// <summary>
        /// 去处int[]数组里面的重复项
        /// </summary>
        /// <param name="myData">用于处理的数组</param>
        /// <returns>返回处理后 没有重复项的数组</returns>
        public static int[] RemoveDup(int[] myData)
        {
            if (myData.Length > 0)
            {
                Array.Sort(myData);

                int size = 1;  //at  least  1  
                for (int i = 1; i < myData.Length; i++)
                    if (myData[i] != myData[i - 1])
                        size++;

                int[] myTempData = new int[size];

                int j = 0;

                myTempData[j++] = myData[0];

                for (int i = 1; i < myData.Length; i++)
                    if (myData[i] != myData[i - 1])
                        myTempData[j++] = myData[i];

                return myTempData;
            }

            return myData;
        }
        /// <summary>
        /// 替换重复的数组元素
        /// </summary>
        /// <param name="ObjStr">字符串</param>
        /// <param name="separator">字符串中的分隔符</param>
        /// <returns>不含重复的数组元素</returns>
        public static string RWDistinct(string ObjStr, string separator)
        {
            int i, s;
            string sResult = "";
            if (ObjStr == string.Empty) { sResult = ""; }
            else
            {
                string[] arrStr = System.Text.RegularExpressions.Regex.Split(ObjStr, separator);
                for (i = 0; i < arrStr.Length; i++)
                {
                    if (i == 0) { sResult = arrStr[0]; }
                    else if (i == 1)
                    { sResult += (arrStr[1] == sResult) ? (string.Empty) : (separator + arrStr[1]); }
                    else
                    {
                        bool StrExist = false;
                        string[] resultArray = System.Text.RegularExpressions.Regex.Split(sResult, separator);
                        for (s = 0; s < resultArray.Length; s++)
                        {
                            if (resultArray[s] == arrStr[i])
                            { StrExist = true; break; }
                        }
                        sResult += StrExist ? string.Empty : (separator + arrStr[i]);
                    }
                }
            }
            return sResult;
        }

        /// <summary>
        /// 客户端输出调式信息
        /// </summary>
        /// <param name="Message">信息内容(字符)</param>
        public static void Text_DebugString(string Message)
        {
            HttpContext.Current.Response.Write(Text_DebugTemplate.Replace("[信息内容]", Message));
        }


        /// <summary>
        /// 客户端输出调式信息,自定义标题。
        /// </summary>
        /// <param name="Message">信息内容(字符)</param>
        /// <param name="Topic">标题</param>
        public static void Text_DebugString(string Message, string Topic)
        {
            HttpContext.Current.Response.Write(Text_DebugTemplate.Replace("[信息内容]", Message).Replace("调试信息", Topic));
        }

        /// <summary>
        /// 客户端输出调式信息
        /// </summary>
        /// <param name="Message">信息内容(字符组)</param>
        public static void Text_DebugString(string[] Message)
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < Message.Length; i++)
            {
                sb.Append(Message[i] + "<br><br>");
            }
            string sMessage = sb.ToString();
            HttpContext.Current.Response.Write(Text_DebugTemplate.Replace("[信息内容]", sMessage));
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="ObjStr"></param>
        /// <param name="separator"></param>
        /// <returns></returns>
        public static string Text_DistinctString(string ObjStr, string separator)
        {
            string text1 = "";
            if (ObjStr == string.Empty)
            {
                text1 = "";
            }
            else
            {
                string[] textArray1 = Regex.Split(ObjStr, separator);
                for (int num1 = 0; num1 < textArray1.Length; num1++)
                {
                    if (num1 == 0)
                    {
                        text1 = textArray1[0];
                        continue;
                    }
                    if (num1 == 1)
                    {
                        text1 = text1 + ((textArray1[1] == text1) ? string.Empty : (separator + textArray1[1]));
                        continue;
                    }
                    bool flag1 = false;
                    string[] textArray2 = Regex.Split(text1, separator);
                    for (int num2 = 0; num2 < textArray2.Length; num2++)
                    {
                        if (textArray2[num2] == textArray1[num1])
                        {
                            flag1 = true;
                            break;
                        }
                    }
                    text1 = text1 + (flag1 ? string.Empty : (separator + textArray1[num1]));
                }
            }
            return text1;
        }

        /// <summary>
        /// 代码内容里的文件，主要处理[IMG]标记里的文件。
        /// </summary>
        /// <param name="UBBContent">UBB代码内容</param>
        /// <returns>所有本地服务器文件的相对（根目录）路径</returns>
        public static string Text_GetUBBFiles(string UBBContent, string FileSperator)
        {
            string str1 = String.Empty;
            UBBContent = UBBContent.ToLower();
            if (UBBContent.IndexOf("[img]") != -1 && UBBContent.IndexOf("[/img]") != -1)
            {
                int i = 0;
                int j = 0;
                int k = 0;
                for (; UBBContent.IndexOf("[img]", i) != -1; i = j + 6)
                {
                    i = UBBContent.IndexOf("[img]", i) + 5;
                    j = UBBContent.IndexOf("[/img]", i);
                    string str2 = UBBContent.Substring(i, j - i);
                    if (str2.IndexOf("http") == -1)
                    {
                        str1 = String.Concat(str1, (k != 0) ? String.Concat(FileSperator, str2) : str2);
                        k++;
                    }
                }
            }
            return str1;
        }

        public static string Text_getByteString(string String, int ByteLen)
        {
            byte[] buffer1 = Encoding.Default.GetBytes(String);
            if (buffer1.Length > ByteLen)
            {
                return Encoding.Default.GetString(buffer1, 0, ByteLen);
            }
            return String;
        }

        public static string Text_GetExt(string FileName)
        {
            if ((FileName != string.Empty) && (FileName.IndexOf(".") != -1))
            {
                return FileName.Substring(FileName.LastIndexOf(".") + 1);
            }
            return string.Empty;
        }

        public static string Text_GetSize(int filesize)
        {
            int num1;
            if (filesize <= 0)
            {
                return "未知";
            }
            if (filesize > 0x100000)
            {
                num1 = filesize / 0x100000;
                return (num1.ToString() + "M");
            }
            if (filesize > 0x400)
            {
                num1 = filesize / 0x400;
                return (num1.ToString() + "K");
            }
            return (filesize.ToString() + "B");
        }



        public static bool Text_RubbishString(string PostString)
        {
            return false;
        }
        #endregion

        #region 字符串长度/截取

        /// <summary>
        /// 检测含有中文字符串的实际长度
        /// </summary>
        /// <param name="str">字符串</param>
        public static int cnLenth(string str)
        {
            System.Text.ASCIIEncoding n = new System.Text.ASCIIEncoding();
            byte[] b = n.GetBytes(str);
            int l = 0; // l 为字符串之实际长度
            for (int i = 0; i <= b.Length - 1; i++)
            {
                if (b[i] == 63) //判断是否为汉字或全脚符号
                {
                    l++;
                }
                l++;
            }
            return l;
        }

        //public static string SubString(string stringToSub, int length)
        //{
        //    Regex regex = new Regex([u4e00-u9fa5]+, RegexOptions.Compiled);
        //    char[] stringChar = stringToSub.ToCharArray();
        //    StringBuilder sb = new StringBuilder();
        //    int nLength = 0;

        //    for(int i = 0; i < stringChar.Length; i++) {
        //        if (regex.IsMatch((stringChar[i]).ToString())) {
        //            sb.Append(stringChar[i]);
        //            nLength += 2;
        //        }
        //        else {
        //            sb.Append(stringChar[i]);
        //            nLength = nLength + 1;
        //        }

        //        if (nLength > length)
        //            break;
        //    }

        //    return sb.ToString();
        //} 

        public static string GetSubString(string str, int length)
        {
            string temp = str;
            int j = 0;
            int k = 0;
            for (int i = 0; i < temp.Length; i++)
            {
                if (Regex.IsMatch(temp.Substring(i, 1), @"[一-龥]+"))
                {
                    j += 2;
                }
                else
                {
                    j += 1;
                }
                if (j <= length)
                {
                    k += 1;
                }
                if (j >= length)
                {
                    return temp.Substring(0, k);
                }
            }
            return temp;
        }

        public static string getStr(string s, int l)
        {
            string temp = s;
            if (Regex.Replace(temp, "[一-龥]", "zz", RegexOptions.IgnoreCase).Length <= l)
            {
                return temp;
            }
            for (int i = temp.Length; i >= 0; i--)
            {
                temp = temp.Substring(0, i);
                if (Regex.Replace(temp, "[一-龥]", "zz", RegexOptions.IgnoreCase).Length <= l - 3)
                {
                    return temp + "";
                }
            }
            return "";
        }


        public static string leftCut(string str_value, int str_len)
        {
            int p_num = 0;
            int i;
            string New_Str_value = "";

            if (str_value == "")
            {
                New_Str_value = "";
            }
            else
            {
                int Len_Num = str_value.Length;

                //if (Len_Num < str_len)
                //{
                // str_len = Len_Num;
                //}


                for (i = 0; i <= Len_Num - 1; i++)
                {
                    //str_value.Substring(i,1);
                    if (i > Len_Num) break;
                    char c = Convert.ToChar(str_value.Substring(i, 1));
                    if (((int)c > 255) || ((int)c < 0))
                    {
                        p_num = p_num + 2;

                    }
                    else
                    {
                        p_num = p_num + 1;

                    }

                    if (p_num >= str_len)
                    {

                        New_Str_value = str_value.Substring(0, i + 1);

                        break;
                    }
                    else
                    {
                        New_Str_value = str_value;
                    }

                }

            }
            return New_Str_value;
        }

        /// <summary>
        /// 字符长度控制 中文 英文识别！
        /// 注：一个汉字作为2个字符长度处理
        /// </summary>
        /// <param name="str">要进行切割的字符串</param>
        /// <param name="len">返回的长度（自动识别中英文）</param>
        /// <returns></returns>
        public static string CutString(string str, int len)
        {
            byte[] sarr = System.Text.Encoding.Default.GetBytes(str);

            if (sarr.Length > len)
                return System.Text.Encoding.Default.GetString(sarr, 0, len) + "...";
            else
                return str;
        }

        /// <summary>
        /// 字符长度控制 中文 英文识别！
        /// 注：一个汉字作为2个字符长度处理
        /// </summary>
        /// <param name="str">要进行切割的字符串</param>
        /// <param name="len">返回的长度（自动识别中英文）</param>
        /// <param name="isExt">是否输出...</param>
        /// <returns></returns>
        public static string CutString(string str, int len, bool isExt)
        {
            byte[] sarr = System.Text.Encoding.Default.GetBytes(str);

            if (sarr.Length > len)
                return System.Text.Encoding.Default.GetString(sarr, 0, len) + (isExt ? "..." : "");
            else
                return str;
        }
        #endregion

        #endregion