字符串处理类收集(实例一)

 

1. using System;
2. using System.Data;
3. using System.Configuration;
4. using System.Web;
5. using System.Web.Security;
6. using System.Web.UI;
7. using System.Web.UI.WebControls;
8. using System.Web.UI.WebControls.WebParts;
9. using System.Web.UI.HtmlControls;
10. using System.IO;
11. using System.Web.SessionState;
12. using System.Xml;
13. using System.Security;
14. using System.Net;
15. using System.Text.RegularExpressions;
16. /// <summary>
17. /// 字符串的处理，字符的转换
18. /// </summary>
19. public class StringUtil
20. {
21.     public StringUtil()
22.     {
23.         //
24.         // TODO: 在此处添加构造函数逻辑
25.         //
26.     }
27.     /// <summary>
28.     /// 从字符串中的尾部删除指定的字符串
29.     /// </summary>
30.     /// <param name="sourceString"></param>
31.     /// <param name="removedString"></param>
32.     /// <returns></returns>
33.     public static string Remove(string sourceString, string removedString)
34.     {
35.         try
36.         {
37.             if (sourceString.IndexOf(removedString) < 0)
38.                 throw new Exception("原字符串中不包含移除字符串！");
39.             string result = sourceString;
40.             int lengthOfSourceString = sourceString.Length;
41.             int lengthOfRemovedString = removedString.Length;
42.             int startIndex = lengthOfSourceString - lengthOfRemovedString;
43.             string tempSubString = sourceString.Substring(startIndex);
44.             if (tempSubString.ToUpper() == removedString.ToUpper())
45.             {
46.                 result = sourceString.Remove(startIndex, lengthOfRemovedString);
47.             }
48.             return result;
49.         }
50.         catch
51.         {
52.             return sourceString;
53.         }
54.     }
56.     /// <summary>
57.     /// 获取拆分符右边的字符串
58.     /// </summary>
59.     /// <param name="sourceString"></param>
60.     /// <param name="splitChar"></param>
61.     /// <returns></returns>
62.     public static string RightSplit(string sourceString, char splitChar)
63.     {
64.         string result = null;
65.         string[] tempString = sourceString.Split(splitChar);
66.         if (tempString.Length > 0)
67.         {
68.             result = tempString[tempString.Length - 1].ToString();
69.         }
70.         return result;
71.     }
73.     /// <summary>
74.     /// 获取拆分符左边的字符串
75.     /// </summary>
76.     /// <param name="sourceString"></param>
77.     /// <param name="splitChar"></param>
78.     /// <returns></returns>
79.     public static string LeftSplit(string sourceString, char splitChar)
80.     {
81.         string result = null;
82.         string[] tempString = sourceString.Split(splitChar);
83.         if (tempString.Length > 0)
84.         {
85.             result = tempString[0].ToString();
86.         }
87.         return result;
88.     }
90.     /// <summary>
91.     /// 去掉最后一个逗号
92.     /// </summary>
93.     /// <param name="origin"></param>
94.     /// <returns></returns>
95.     public static string DelLastComma(string origin)
96.     {
97.         if (origin.IndexOf(",") == -1)
98.         {
99.             return origin;
100.         }
101.         return origin.Substring(0, origin.LastIndexOf(","));
102.     }
104.     /// <summary>
105.     /// 删除不可见字符
106.     /// </summary>
107.     /// <param name="sourceString"></param>
108.     /// <returns></returns>
109.     public static string DeleteUnVisibleChar(string sourceString)
110.     {
111.         System.Text.StringBuilder sBuilder = new System.Text.StringBuilder(131);
112.         for (int i = 0; i < sourceString.Length; i++)
113.         {
114.             int Unicode = sourceString[i];
115.             if (Unicode >= 16)
116.             {
117.                 sBuilder.Append(sourceString[i].ToString());
118.             }
119.         }
120.         return sBuilder.ToString();
121.     }
123.     /// <summary>
124.     /// 获取数组元素的合并字符串
125.     /// </summary>
126.     /// <param name="stringArray"></param>
127.     /// <returns></returns>
128.     public static string GetArrayString(string[] stringArray)
129.     {
130.         string totalString = null;
131.         for (int i = 0; i < stringArray.Length; i++)
132.         {
133.             totalString = totalString + stringArray[i];
134.         }
135.         return totalString;
136.     }
138.     /// <summary>
139.     ///     获取某一字符串在字符串数组中出现的次数
140.     /// </summary>
141.     /// <param name="stringArray" type="string[]">
142.     ///     <para>
143.     ///         
144.     ///     </para>
145.     /// </param>
146.     /// <param name="findString" type="string">
147.     ///     <para>
148.     ///         
149.     ///     </para>
150.     /// </param>
151.     /// <returns>
152.     ///     A int value...
153.     /// </returns>
154.     public static int GetStringCount(string[] stringArray, string findString)
155.     {
156.         int count = -1;
157.         string totalString = GetArrayString(stringArray);
158.         string subString = totalString;
160.         while (subString.IndexOf(findString) >= 0)
161.         {
162.             subString = totalString.Substring(subString.IndexOf(findString));
163.             count += 1;
164.         }
165.         return count;
166.     }
168.     /// <summary>
169.     ///     获取某一字符串在字符串中出现的次数
170.     /// </summary>
171.     /// <param name="stringArray" type="string">
172.     ///     <para>
173.     ///         原字符串
174.     ///     </para>
175.     /// </param>
176.     /// <param name="findString" type="string">
177.     ///     <para>
178.     ///         匹配字符串
179.     ///     </para>
180.     /// </param>
181.     /// <returns>
182.     ///     匹配字符串数量
183.     /// </returns>
184.     public static int GetStringCount(string sourceString, string findString)
185.     {
186.         int count = 0;
187.         int findStringLength = findString.Length;
188.         string subString = sourceString;
190.         while (subString.IndexOf(findString) >= 0)
191.         {
192.             subString = subString.Substring(subString.IndexOf(findString) + findStringLength);
193.             count += 1;
194.         }
195.         return count;
196.     }
198.     /// <summary>
199.     /// 截取从startString开始到原字符串结尾的所有字符   
200.     /// </summary>
201.     /// <param name="sourceString" type="string">
202.     ///     <para>
203.     ///         
204.     ///     </para>
205.     /// </param>
206.     /// <param name="startString" type="string">
207.     ///     <para>
208.     ///         
209.     ///     </para>
210.     /// </param>
211.     /// <returns>
212.     ///     A string value...
213.     /// </returns>
214.     public static string GetSubString(string sourceString, string startString)
215.     {
216.         try
217.         {
218.             int index = sourceString.ToUpper().IndexOf(startString);
219.             if (index > 0)
220.             {
221.                 return sourceString.Substring(index);
222.             }
223.             return sourceString;
224.         }
225.         catch
226.         {
227.             return "";
228.         }
229.     }
231.     public static string GetSubString(string sourceString, string beginRemovedString, string endRemovedString)
232.     {
233.         try
234.         {
235.             if (sourceString.IndexOf(beginRemovedString) != 0)
236.                 beginRemovedString = "";
238.             if (sourceString.LastIndexOf(endRemovedString, sourceString.Length - endRemovedString.Length) < 0)
239.                 endRemovedString = "";
241.             int startIndex = beginRemovedString.Length;
242.             int length = sourceString.Length - beginRemovedString.Length - endRemovedString.Length;
243.             if (length > 0)
244.             {
245.                 return sourceString.Substring(startIndex, length);
246.             }
247.             return sourceString;
248.         }
249.         catch
250.         {
251.             return sourceString; ;
252.         }
253.     }
255.     /// <summary>
256.     /// 按字节数取出字符串的长度
257.     /// </summary>
258.     /// <param name="strTmp">要计算的字符串</param>
259.     /// <returns>字符串的字节数</returns>
260.     public static int GetByteCount(string strTmp)
261.     {
262.         int intCharCount = 0;
263.         for (int i = 0; i < strTmp.Length; i++)
264.         {
265.             if (System.Text.UTF8Encoding.UTF8.GetByteCount(strTmp.Substring(i, 1)) == 3)
266.             {
267.                 intCharCount = intCharCount + 2;
268.             }
269.             else
270.             {
271.                 intCharCount = intCharCount + 1;
272.             }
273.         }
274.         return intCharCount;
275.     }
277.     /// <summary>
278.     /// 按字节数要在字符串的位置
279.     /// </summary>
280.     /// <param name="intIns">字符串的位置</param>
281.     /// <param name="strTmp">要计算的字符串</param>
282.     /// <returns>字节的位置</returns>
283.     public static int GetByteIndex(int intIns, string strTmp)
284.     {
285.         int intReIns = 0;
286.         if (strTmp.Trim() == "")
287.         {
288.             return intIns;
289.         }
290.         for (int i = 0; i < strTmp.Length; i++)
291.         {
292.             if (System.Text.UTF8Encoding.UTF8.GetByteCount(strTmp.Substring(i, 1)) == 3)
293.             {
294.                 intReIns = intReIns + 2;
295.             }
296.             else
297.             {
298.                 intReIns = intReIns + 1;
299.             }
300.             if (intReIns >= intIns)
301.             {
302.                 intReIns = i + 1;
303.                 break;
304.             }
305.         }
306.         return intReIns;
307.     }
309.     /// <summary>
310.     /// Method to make sure that user's inputs are not malicious
311.     /// 截取输入最大的字符串
312.     /// </summary>
313.     /// <param name="text">User's Input</param>
314.     /// <param name="maxLength">Maximum length of input</param>
315.     /// <returns>The cleaned up version of the input</returns>
316.     public static string InputText(string text, int maxLength)
317.     {
318.         text = text.Trim();
319.         if (string.IsNullOrEmpty(text))
320.             return string.Empty;
321.         if (text.Length > maxLength)
322.             text = text.Substring(0, maxLength);
323.         text = Regex.Replace(text, "[//s]{2,}", " ");   //two or more spaces
324.         text = Regex.Replace(text, "(<[b|B][r|R]/*>)+|(<[p|P](.|//n)*?>)", "/n");   //<br>
325.         text = Regex.Replace(text, "(//s*&[n|N][b|B][s|S][p|P];//s*)+", " ");   // 
326.         text = Regex.Replace(text, "<(.|//n)*?>", string.Empty);    //any other tags
327.         text = text.Replace("'", "''");
328.         return text;
329.     }
331.     /// <summary>
332.     /// Method to check whether input has other characters than numbers
333.     /// 清楚字符
334.     /// </summary>
335.     public static string CleanNonWord(string text)
336.     {
337.         return Regex.Replace(text, "//W", "");
338.     }
340.     //特殊字符的转换
341.     public static string Encode(string str)
342.     {
344.         str = str.Replace("'", "＇");
345.         str = str.Replace("/"", """);
346.         str = str.Replace("<", "<");
347.         str = str.Replace(">", ">");
348.         return str;
349.     }
350.     public static string Decode(string str)
351.     {
353.         str = str.Replace(">", ">");
354.         str = str.Replace("<", "<");
355.         str = str.Replace(" ", " ");
356.         str = str.Replace(""", "/"");
357.         return str;
358.     }
359.     //字符传的转换 用在查询 登陆时 防止恶意的盗取密码
360.     public static string TBCode(string strtb)
361.     {
362.         strtb = strtb.Replace("!", "");
363.         strtb = strtb.Replace("@", "");
364.         strtb = strtb.Replace("#", "");
365.         strtb = strtb.Replace("$", "");
366.         strtb = strtb.Replace("%", "");
367.         strtb = strtb.Replace("^", "");
368.         strtb = strtb.Replace("&", "");
369.         strtb = strtb.Replace("*", "");
370.         strtb = strtb.Replace("(", "");
371.         strtb = strtb.Replace(")", "");
372.         strtb = strtb.Replace("_", "");
373.         strtb = strtb.Replace("+", "");
374.         strtb = strtb.Replace("|", "");
375.         strtb = strtb.Replace("?", "");
376.         strtb = strtb.Replace("/", "");
377.         strtb = strtb.Replace(".", "");
378.         strtb = strtb.Replace(">", "");
379.         strtb = strtb.Replace("<", "");
380.         strtb = strtb.Replace("{", "");
381.         strtb = strtb.Replace("}", "");
382.         strtb = strtb.Replace("[", "");
383.         strtb = strtb.Replace("]", "");
384.         strtb = strtb.Replace("-", "");
385.         strtb = strtb.Replace("=", "");
386.         strtb = strtb.Replace(",", "");
387.         return strtb;
388.     }
390.     //以javascript的windous.alert()方法输出提示信息
391.     //strmsg 表示要输出的信息
392.     //back 表示输出后是否要history.back()
393.     //end 表示输出后是否要Response.End()
394.     public static void WriteMessage(string strMsg, bool Back, bool End)
395.     {
396.         string js = "";
397.        // Response = HttpContext.Current.Response;
398.         //将单引号替换,防止js出错
399.         strMsg = strMsg.Replace("'", "");
400.         //将回车符号换掉,防止js出错
401.         strMsg = strMsg.Replace("/r/n", "");
402.        js="<script language=javascript>alert('" + strMsg + "')</script>";
403.         if (Back)
404.         {
405.             js="<script language=javascript>history.back();</script)";
406.         }
407.         if (End)
408.         {
409.             js = "<script language=javascript>End</script)";
410.         }
411.         HttpContext.Current.Response.Write(js);   
412.     }
414.     /// <summary>
415.     /// 小函数，将字符串转换成float型，若字符串为空，返回0
416.     /// </summary>
417.     /// <param name="str">要转换的字符串</param>
418.     /// <returns>转后的float值</returns>
419.     public static float GetFloatValue(string str)
420.     {
421.         try
422.         {
423.             if (str.Length == 0)
424.                 return 0;
425.             else
426.                 return float.Parse(str);
427.         }
428.         catch
429.         {
430.             WriteMessage("数据转换失败，请检查数据是否合理！", true, true);
431.             return 0;
432.         }
433.     }
434.     /// <summary>
435.     /// 小函数，将字符串转换成int型，若字符串为空，返回0
436.     /// </summary>
437.     /// <param name="str">要转换的字符串</param>
438.     /// <returns>转后的int值</returns>
439.     public static int GetIntValue(string str)
440.     {
441.         try
442.         {
443.             if (str.Length == 0)
444.                 return 0;
445.             else
446.             {
447.                 if (Int32.Parse(str) == 0)
448.                     return 0;
449.                 else
450.                     return Int32.Parse(str);
451.             }
452.         }
453.         catch
454.         {
455.             WriteMessage("数据转换失败，请检查数据是否合理！", true, true);
456.             return 0;
457.         }
458.     }
459. }