一个项目中使用到的通用函数库(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(">", ">").Replace("<", "<").Replace("&", "&");
}

/// <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(" ", " ");
}
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>
/// 代码内容里的文件，主要处理/// <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("" border="0" >") != -1)
{
int i = 0;
int j = 0;
int k = 0;
for (; UBBContent.IndexOf("{
i = UBBContent.IndexOf("[img]", i) + 5;
j = UBBContent.IndexOf("" border="0" >", 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