一个项目中使用到的通用函数库(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