一个项目中使用到的通用函数库(2) 字符操作
2007-10-28 17:43
393 查看
字符操作#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>
/// 代码内容里的文件，主要处理
/// </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("
...{
int i = 0;
int j = 0;
int k = 0;
for (; UBBContent.IndexOf("
[img]http://images.csdn.net/syntaxhighlighting/OutliningIndicators/ExpandedSubBlockStart.gif" border="0" >
...{
i = UBBContent.IndexOf("
[img]http://images.csdn.net/syntaxhighlighting/OutliningIndicators/InBlock.gif" border="0" >
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
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 一个项目中使用到的通用函数库(2) 字符操作
- 一个项目中使用到的通用函数库(3) 文件IO操作！
- 一个项目中使用到的通用函数库(3) 文件IO操作！
- 【c语言】编写一个函数reverse_string(char * string) 实现：将参数字符串中的字符反向排列。 要求：不能使用C函数库中的字符串操作函数
- 一个项目中使用到的通用函数库(5) 汉字相关操作
- 编写一个函数reverse_string(char * string)（递归实现） 实现：将参数字符串中的字符反向排列。 要求：不能使用C函数库中 的字符串操作函数。
- C语言 编写一个函数reverse_string(char * string) 实现：将参数字符串中的字符反向排列。 要求：不能使用C函数库中的字符串操作函数。
- C语言 编写一个函数，将参数字符串中的字符反向排列。要求：不能使用C函数库中的字符串操作函数，
- 【C语言】编写一个函数reverse_string(char * string)（递归实现），将参数字符串中的字符反向排列，不能使用C函数库中的字符串操作函数。
- //4. 编写一个函数reverse_string(char * string)（递归实现） //实现：将参数字符串中的字符反向排列。 //要求：不能使用C函数库中的字符串操作函数。
- 一个项目中使用到的通用函数库(1)
- 【C语言】编写一个函数reverse_string(char * string) 实现：将参数字符串中的字符反向排列。要求：不能使用C函数库中的字符串操作函数。
- 使用Makefile管理一个小项目：链表的增删改查操作和测试程序
- 编写一个函数reverse_string(char * string) 实现：将参数字符串中的字符反向排列。 要求：不能使用C函数库中的字符串操作函数。
- 一个项目中使用到的通用函数库(1)
- 一个项目中使用到的通用函数库(4) 客户端信息相关
- 如何在一个项目中完美融入GreenDao并使用Facde设计模式操作数据库
- 第十三周 项目五--字符串操作（2.2）字符串复制功能---两个数组中的字符复制在一个数组中
- 编写一个函数reverse_string(char * string)（递归实现）实现：将参数字符串中的字符反向排列。要求：不能使用C函数库中的字符串操作函数。
- 编写一个函数reverse_string(char * string) 实现：将参数字符串中的字符反向排列。 要求：不能使用C函数库中的字符串操作函数