1 using System;
2 using System.Collections;
3 using System.Text;
4 using System.Text.RegularExpressions;
5
6 namespace Commons.Helpers
7 {
8 /// <summary>
9 /// 字符串操作助手类
10 /// </summary>
11 public class StringHelper
12 {
13 #region 获取处理好的行数据
14 public static SortedList GetSortedList(string line)
15 {
16 string src = line.Replace("\"\"", "\'");
17
18 MatchCollection col = Regex.Matches(src, ",\"([^\"]+)\",", RegexOptions.ExplicitCapture);
19
20 SortedList sl = new SortedList();
21 IEnumerator ie = col.GetEnumerator();
22 while (ie.MoveNext())
23 {
24 string patn = ie.Current.ToString();
25 int key = src.Substring(0, src.IndexOf(patn)).Split(\',\').Length;
26 if (!sl.ContainsKey(key))
27 {
28 sl.Add(key, patn.Trim(new[] { \',\', \'"\' }).Replace("\'", "\""));
29 src = src.Replace(patn, ",,");
30 }
31 }
32
33 string[] arr = src.Split(\',\');
34 for (int i = 0; i < arr.Length; i++)
35 {
36 if (!sl.ContainsKey(i))
37 {
38 sl.Add(i, arr[i]);
39 }
40 }
41
42 return sl;
43 }
44 #endregion
45
46 #region 字符串左补零
47 /// <summary>
48 /// 字符串左补零
49 /// </summary>
50 /// <param name="inStr">原字符串</param>
51 /// <param name="len">补零后字符串的总长</param>
52 /// <returns></returns>
53 public static string StringPadLeftZero(string inStr, int len)
54 {
55 string outStr = inStr;
56
57 if (inStr.Length < len)
58 {
59 outStr = inStr.PadLeft(len, \'0\');
60 }
61
62 return outStr;
63 }
64 #endregion
65
66 #region 转换中文的逗号并去掉最后的逗号
67 /// <summary>
68 /// 转换中文的逗号并去掉最后的逗号
69 /// </summary>
70 /// <param name="strList">逗号串起来的字符串</param>
71 /// <returns>最后没用逗号的字符串</returns>
72 public static string DeleteLastComma(string strList)
73 {
74 //判断是否为空
75 if (!String.IsNullOrEmpty(strList))
76 {
77 //转换中文的逗号
78 strList = Regex.Replace(strList, "，", ",");
79 //判断最后一位是否逗号
80 while (strList.IndexOf(\',\') == 0 || strList.LastIndexOf(\',\') == strList.Length - 1)
81 {
82 strList = strList.IndexOf(\',\') == 0 ? strList.Substring(1) : strList;
83 strList = strList.LastIndexOf(\',\') == strList.Length - 1 ? strList.Substring(0, strList.Length - 1) : strList;
84 }
85 }
86 return strList;
87 }
88 #endregion
89
90 #region 过滤特殊符号
91 /// <summary>
92 /// 过滤特殊符号
93 /// </summary>
94 /// <param name="text">字符串</param>
95 /// <returns>返回特殊符号</returns>
96 public static string FilerSymbol(string text)
97 {
98 StringBuilder sb = new StringBuilder();
99 string symbol = "@,#,$,*,_,&,^,|,\\,/";
100 string[] symbolGroup = symbol.Split(\',\');
101
102 foreach (string t in symbolGroup)
103 {
104 int exist = text.IndexOf(t);
105
106 //判断是否存在特殊符号
107 if (exist != -1)
108 {
109 sb.Append(t);
110 sb.Append(",");
111 }
112 }
113 string result = DeleteLastComma(sb.ToString());
114
115 return result;
116 }
117 #endregion
118
119 #region 自定义的替换字符串函数
120 /// <summary>
121 /// 自定义的替换字符串函数
122 /// </summary>
123 public static string ReplaceSymbol(string text)
124 {
125 string symbol = "@,#,$,*,~,&,^,|,\\,/,%,(,),+,{,},:,;,.,<,>,?,\",\',!,[,],`,€";
126 string[] symbolGroup = symbol.Split(\',\');
127
128 foreach (string t in symbolGroup)
129 {
130 text = text.Replace(t, "_");
131 }
132
133 return text.Replace(" ", "").Replace(",", "");
134 }
135 #endregion
136
137 #region 合并字符
138 /// <summary>
139 /// 合并字符
140 /// </summary>
141 /// <param name="source">要合并的源字符串</param>
142 /// <param name="target">要被合并到的目的字符串</param>
143 /// <returns>合并到的目的字符串</returns>
144 public static string MergeString(string source, string target)
145 {
146 return MergeString(source, target, ",");
147 }
148
149 /// <summary>
150 /// 合并字符
151 /// </summary>
152 /// <param name="source">要合并的源字符串</param>
153 /// <param name="target">要被合并到的目的字符串</param>
154 /// <param name="mergechar">合并符</param>
155 /// <returns>并到字符串</returns>
156 public static string MergeString(string source, string target, string mergechar)
157 {
158 if (String.IsNullOrEmpty(target))
159 {
160 target = source;
161 }
162 else
163 {
164 target += mergechar + source;
165 }
166 return target;
167 }
168 #endregion
169
170 #region 删除最后一个字符
171 /// <summary>
172 /// 删除最后一个字符
173 /// </summary>
174 /// <param name="str">字符串</param>
175 /// <returns></returns>
176 public static string ClearLastChar(string str)
177 {
178 if (str == "")
179 {
180 return "";
181 }
182
183 return str.Substring(0, str.Length - 1);
184 }
185 #endregion
186
187 #region 替换回车换行符为html换行符
188 /// <summary>
189 /// 替换回车换行符为html换行符
190 /// </summary>
191 /// <param name="str">字符串</param>
192 /// <returns></returns>
193 public static string StrFormat(string str)
194 {
195 string str2;
196
197 if (str == null)
198 {
199 str2 = "";
200 }
201 else
202 {
203 str = str.Replace("\r\n", "<br />");
204 str = str.Replace("\n", "<br />");
205 str2 = str;
206 }
207 return str2;
208 }
209 #endregion
210
211 #region 删除字符串尾部的回车/换行/空格
212 /// <summary>
213 /// 删除字符串尾部的回车/换行/空格
214 /// </summary>
215 /// <param name="str">字符串</param>
216 /// <returns></returns>
217 public static string RTrim(string str)
218 {
219 for (int i = str.Length; i >= 0; i--)
220 {
221 if (str[i].Equals(" ") || str[i].Equals("\r") || str[i].Equals("\n"))
222 {
223 return str.Remove(i, 1);
224 }
225 }
226 return str;
227 }
228 #endregion
229
230 #region 生成指定数量的html空格符号
231 /// <summary>
232 /// 生成指定数量的html空格符号
233 /// </summary>
234 /// <param name="spacesCount">空格数量</param>
235 /// <returns></returns>
236 public static string GetSpacesString(int spacesCount)
237 {
238 StringBuilder sb = new StringBuilder();
239 for (int i = 0; i < spacesCount; i++)
240 {
241 sb.Append(" ");
242 }
243 return sb.ToString();
244 }
245 #endregion
246
247 #region 从字符串的指定位置截取指定长度的子字符串
248 /// <summary>
249 /// 从字符串的指定位置截取指定长度的子字符串
250 /// </summary>
251 /// <param name="str">原字符串</param>
252 /// <param name="startIndex">子字符串的起始位置</param>
253 /// <param name="length">子字符串的长度</param>
254 /// <returns>子字符串</returns>
255 public static string CutString(string str, int startIndex, int length)
256 {
257 if (startIndex >= 0)
258 {
259 if (length < 0)
260 {
261 length = length * -1;
262 if (startIndex - length < 0)
263 {
264 length = startIndex;
265 startIndex = 0;
266 }
267 else
268 {
269 startIndex = startIndex - length;
270 }
271 }
272
273 if (startIndex > str.Length)
274 {
275 return "";
276 }
277 }
278 else
279 {
280 if (length < 0)
281 {
282 return "";
283 }
284
285 if (length + startIndex > 0)
286 {
287 length = length + startIndex;
288 startIndex = 0;
289 }
290 else
291 {
292 return "";
293 }
294 }
295
296 if (str.Length - startIndex < length)
297 {
298 length = str.Length - startIndex;
299 }
300
301 return str.Substring(startIndex, length);
302 }
303 #endregion
304
305 #region 从字符串的指定位置开始截取到字符串结尾的了符串
306 /// <summary>
307 /// 从字符串的指定位置开始截取到字符串结尾的了符串
308 /// </summary>
309 /// <param name="str">原字符串</param>
310 /// <param name="startIndex">子字符串的起始位置</param>
311 /// <returns>子字符串</returns>
312 public static string CutString(string str, int startIndex)
313 {
314 return CutString(str, startIndex, str.Length);
315 }
316 #endregion
317
318 #region 返回字符串真实长度, 1个汉字长度为2
319 /// <summary>
320 /// 返回字符串真实长度, 1个汉字长度为2
321 /// </summary>
322 /// <param name="str">字符串</param>
323 /// <returns>字符长度</returns>
324 public static int GetStringLength(string str)
325 {
326 return Encoding.Default.GetBytes(str).Length;
327 }
328 #endregion
329
330 #region 字符串如果操过指定长度则将超出的部分用指定字符串代替
331 /// <summary>
332 /// 字符串如果操过指定长度则将超出的部分用指定字符串代替
333 /// </summary>
334 /// <param name="p_SrcString">要检查的字符串</param>
335 /// <param name="p_Length">指定长度</param>
336 /// <param name="p_TailString">用于替换的字符串</param>
337 /// <returns>截取后的字符串</returns>
338 public static string GetSubString(string p_SrcString, int p_Length, string p_TailString)
339 {
340 return GetSubString(p_SrcString, 0, p_Length, p_TailString);
341 }
342 #endregion
343
344 #region 取指定长度的字符串
345 /// <summary>
346 /// 取指定长度的字符串
347 /// </summary>
348 /// <param name="p_SrcString">要检查的字符串</param>
349 /// <param name="p_StartIndex">起始位置</param>
350 /// <param name="p_Length">指定长度</param>
351 /// <param name="p_TailString">用于替换的字符串</param>
352 /// <returns>截取后的字符串</returns>
353 public static string GetSubString(string p_SrcString, int p_StartIndex, int p_Length, string p_TailString)
354 {
355 string myResult = p_SrcString;
356
357 Byte[] bComments = Encoding.UTF8.GetBytes(p_SrcString);
358 foreach (char c in Encoding.UTF8.GetChars(bComments))
359 {
360 //当是日文或韩文时(注:中文的范围:\u4e00 - \u9fa5, 日文在\u0800 - \u4e00, 韩文为\xAC00-\xD7A3)
361 if ((c > \'\u0800\' && c < \'\u4e00\') || (c > \'\xAC00\' && c < \'\xD7A3\'))
362 {
363 //if (System.Text.RegularExpressions.Regex.IsMatch(p_SrcString, "[\u0800-\u4e00]+") || System.Text.RegularExpressions.Regex.IsMatch(p_SrcString, "[\xAC00-\xD7A3]+"))
364 //当截取的起始位置超出字段串长度时
365 if (p_StartIndex >= p_SrcString.Length)
366 {
367 return "";
368 }
369
370 return p_SrcString.Substring(p_StartIndex,
371 ((p_Length + p_StartIndex) > p_SrcString.Length) ? (p_SrcString.Length - p_StartIndex) : p_Length);
372 }
373 }
374
375 if (p_Length >= 0)
376 {
377 byte[] bsSrcString = Encoding.Default.GetBytes(p_SrcString);
378
379 //当字符串长度大于起始位置
380 if (bsSrcString.Length > p_StartIndex)
381 {
382 int p_EndIndex = bsSrcString.Length;
383
384 //当要截取的长度在字符串的有效长度范围内
385 if (bsSrcString.Length > (p_StartIndex + p_Length))
386 {
387 p_EndIndex = p_Length + p_StartIndex;
388 }
389 else
390 { //当不在有效范围内时,只取到字符串的结尾
391
392 p_Length = bsSrcString.Length - p_StartIndex;
393 p_TailString = "";
394 }
395
396 int nRealLength = p_Length;
397 int[] anResultFlag = new int[p_Length];
398
399 int nFlag = 0;
400 for (int i = p_StartIndex; i < p_EndIndex; i++)
401 {
402 if (bsSrcString[i] > 127)
403 {
404 nFlag++;
405 if (nFlag == 3)
406 {
407 nFlag = 1;
408 }
409 }
410 else
411 {
412 nFlag = 0;
413 }
414
415 anResultFlag[i] = nFlag;
416 }
417
418 if ((bsSrcString[p_EndIndex - 1] > 127) && (anResultFlag[p_Length - 1] == 1))
419 {
420 nRealLength = p_Length + 1;
421 }
422
423 byte[] bsResult = new byte[nRealLength];
424
425 Array.Copy(bsSrcString, p_StartIndex, bsResult, 0, nRealLength);
426
427 myResult = Encoding.Default.GetString(bsResult);
428
429 myResult = myResult + p_TailString;
430 }
431 }
432
433 return myResult;
434 }
435 #endregion
436
437 #region 取指定长度的字符串 中文字符计算加2
438 public static string GetUnicodeSubString(string str, int len, string p_TailString)
439 {
440 string result = String.Empty;// 最终返回的结果
441 int byteLen = Encoding.Default.GetByteCount(str);// 单字节字符长度
442 int charLen = str.Length;// 把字符平等对待时的字符串长度
443 int byteCount = 0;// 记录读取进度
444 int pos = 0;// 记录截取位置
445 if (byteLen > len)
446 {
447 for (int i = 0; i < charLen; i++)
448 {
449 if (Convert.ToInt32(str.ToCharArray()[i]) > 255)// 按中文字符计算加2
450 byteCount += 2;
451 else// 按英文字符计算加1
452 byteCount += 1;
453 if (byteCount > len)// 超出时只记下上一个有效位置
454 {
455 pos = i;
456 break;
457 }
458
459 if (byteCount == len)// 记下当前位置
460 {
461 pos = i + 1;
462 break;
463 }
464 }
465
466 if (pos >= 0)
467 {
468 result = str.Substring(0, pos) + p_TailString;
469 }
470 }
471 else
472 {
473 result = str;
474 }
475
476 return result;
477 }
478 #endregion
479
480 #region 自定义的替换字符串函数
481 /// <summary>
482 /// 自定义的替换字符串函数
483 /// </summary>
484 public static string ReplaceString(string SourceString, string SearchString, string ReplaceString, bool IsCaseInsensetive)
485 {
486 return Regex.Replace(SourceString, Regex.Escape(SearchString), ReplaceString, IsCaseInsensetive ? RegexOptions.IgnoreCase : RegexOptions.None);
487 }
488 #endregion
489
490 #region 过滤危险脚本
491 public static string WipeScript(string html)
492 {
493 Regex regex1 = new Regex(@"<script[\s\s]+</script *>", RegexOptions.IgnoreCase);
494 Regex regex2 = new Regex(@" href *= *[\s\s]*script *:", RegexOptions.IgnoreCase);
495 Regex regex3 = new Regex(@" on[\s\s]*=", RegexOptions.IgnoreCase);
496 Regex regex4 = new Regex(@"<iframe[\s\s]+</iframe *>", RegexOptions.IgnoreCase);
497 Regex regex5 = new Regex(@"<frameset[\s\s]+</frameset *>", RegexOptions.IgnoreCase);
498 html = regex1.Replace(html, ""); //过滤<script></script>标记
499 html = regex2.Replace(html, ""); //过滤href=javascript: (<a>) 属性
500 html = regex3.Replace(html, " _disibledevent="); //过滤其它控件的on...事件
501 html = regex4.Replace(html, ""); //过滤iframe
502 html = regex5.Replace(html, ""); //过滤frameset
503 return html;
504 }
505 #endregion
506
507 #region 分割字符串
508 /// <summary>
509 /// 分割字符串
510 /// </summary>
511 /// <param name="strContent">被分割的字符串</param>
512 /// <param name="strSplit">分隔符</param>
513 /// <returns></returns>
514 public static string[] SplitString(string strContent, string strSplit)
515 {
516 if (!String.IsNullOrEmpty(strContent))
517 {
518 if (strContent.IndexOf(strSplit) < 0)
519 {
520 string[] tmp = { strContent };
521 return tmp;
522 }
523 return Regex.Split(strContent, Regex.Escape(strSplit), RegexOptions.IgnoreCase);
524 }
525
526 return new string[] { };
527 }
528
529 /// <summary>
530 /// 分割字符串
531 /// </summary>
532 /// <param name="strContent">被分割的字符串</param>
533 /// <param name="strSplit">分隔符</param>
534 /// <param name="count">数组的数量</param>
535 /// <returns></returns>
536 public static string[] SplitString(string strContent, string strSplit, int count)
537 {
538 string[] result = new string[count];
539
540 string[] splited = SplitString(strContent, strSplit);
541
542 for (int i = 0; i < count; i++)
543 {
544 result[i] = i < splited.Length ? splited[i] : String.Empty;
545 }
546
547 return result;
548 }
549
550 /// <summary>
551 /// 分割字符串
552 /// </summary>
553 /// <param name="strContent">被分割的字符串</param>
554 /// <param name="strSplit">分割符</param>
555 /// <param name="ignoreRepeatItem">忽略重复项</param>
556 /// <param name="maxElementLength">单个元素最大长度</param>
557 /// <returns></returns>
558 public static string[] SplitString(string strContent, string strSplit, bool ignoreRepeatItem, int maxElementLength)
559 {
560 string[] result = SplitString(strContent, strSplit);
561
562 return ignoreRepeatItem ? ArrayHelper.DistinctStringArray(result, maxElementLength) : result;
563 }
564
565 public static string[] SplitString(string strContent, string strSplit, bool ignoreRepeatItem, int minElementLength, int maxElementLength)
566 {
567 string[] result = SplitString(strContent, strSplit);
568
569 if (ignoreRepeatItem)
570 {
571 result = ArrayHelper.DistinctStringArray(result);
572 }
573 return ArrayHelper.PadStringArray(result, minElementLength, maxElementLength);
574 }
575
576 /// <summary>
577 /// 分割字符串
578 /// </summary>
579 /// <param name="strContent">被分割的字符串</param>
580 /// <param name="strSplit">分割符</param>
581 /// <param name="ignoreRepeatItem">忽略重复项</param>
582 /// <returns></returns>
583 public static string[] SplitString(string strContent, string strSplit, bool ignoreRepeatItem)
584 {
585 return SplitString(strContent, strSplit, ignoreRepeatItem, 0);
586 }
587 #endregion
588
589 #region 字符串重复
590 /// <summary>
591 /// 字符串重复N倍
592 /// </summary>
593 /// <param name="str"></param>
594 /// <param name="n"></param>
595 /// <returns></returns>
596 public static string RepeatString(string str, int n)
597 {
598 char[] arr = str.ToCharArray();
599 char[] arrDest = new char[arr.Length * n];
600 for (int i = 0; i < n; i++)
601 {
602 Buffer.BlockCopy(arr, 0, arrDest, i * arr.Length * 2, arr.Length * 2);
603 }
604
605 return new string(arrDest);
606 }
607 #endregion
608
609 #region Base64解码
610 /// <summary>
611 /// Base64解码
612 /// </summary>
613 /// <param name="str"></param>
614 /// <returns></returns>
615 public static string Base64_Decode(string str)
616 {
617 byte[] bytes = Convert.FromBase64String(str);
618 return Encoding.UTF8.GetString(bytes);
619 }
620 #endregion
621
622 #region Base64编码
623 /// <summary>
624 /// Base64编码
625 /// </summary>
626 /// <param name="str"></param>
627 /// <returns></returns>
628 public static string Base64_Encode(string str)
629 {
630 return Convert.ToBase64String(Encoding.UTF8.GetBytes(str));
631 }
632 #endregion
633
634 #region 清理无效XML字符
635 /// <summary>
636 /// 清理无效XML字符
637 /// </summary>
638 /// <param name="input"></param>
639 /// <returns></returns>
640 public static string CleanInvalidCharsForXML(string input)
641 {
642 if (String.IsNullOrEmpty(input))
643 {
644 return input;
645 }
646 StringBuilder builder = new StringBuilder();
647 char[] chArray = input.ToCharArray();
648 foreach (char t in chArray)
649 {
650 int num2 = Convert.ToInt32(t);
651 if ((((num2 < 0) || (num2 > 8)) && ((num2 < 11) || (num2 > 12))) && ((num2 < 14) || (num2 > 0x1f)))
652 {
653 builder.Append(t);
654 }
655 }
656 return builder.ToString();
657 }
658 #endregion
659
660 #region 防SQL注入
661 /// <summary>
662 /// 防SQL注入
663 /// </summary>
664 /// <param name="sql"></param>
665 /// <returns></returns>
666 public static string StripSQLInjection(string sql)
667 {
668 if (!String.IsNullOrEmpty(sql))
669 {
670 string pattern = @"(\%27)|(\\')|(\-\-)";
671 string str2 = @"((\%27)|(\\'))\s*((\%6F)|o|(\%4F))((\%72)|r|(\%52))";
672 string str3 = @"\s+exec(\s|\+)+(s|x)p\w+";
673 sql = Regex.Replace(sql, pattern, String.Empty, RegexOptions.IgnoreCase);
674 sql = Regex.Replace(sql, str2, String.Empty, RegexOptions.IgnoreCase);
675 sql = Regex.Replace(sql, str3, String.Empty, RegexOptions.IgnoreCase);
676 }
677 return sql;
678 }
679 #endregion
680
681 #region 截取字符
682 public static string Trim(string stringTrim, int maxLength)
683 {
684 return Trim(stringTrim, maxLength, "...");
685 }
686
687 public static string Trim(string rawString, int maxLength, string appendString)
688 {
689 if (String.IsNullOrEmpty(rawString) || (rawString.Length <= maxLength))
690 {
691 return rawString;
692 }
693 if (Encoding.UTF8.GetBytes(rawString).Length <= (maxLength * 2))
694 {
695 return rawString;
696 }
697 int length = Encoding.UTF8.GetBytes(appendString).Length;
698 StringBuilder builder = new StringBuilder();
699 int num3 = 0;
700 foreach (char ch in rawString)
701 {
702 builder.Append(ch);
703 num3 += Encoding.Default.GetBytes(new[] { ch }).Length;
704 if (num3 >= ((maxLength * 2) - length))
705 {
706 break;
707 }
708 }
709 return (builder + appendString);
710 }
711 #endregion
712
713 #region 生成时间截
714 public static string GenerateTimeStamp()
715 {
716 TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
717 return Convert.ToInt64(ts.TotalSeconds).ToString();
718 }
719 #endregion
720
721 #region 替换sql语句中的有问题符号
722 /// <summary>
723 /// 替换sql语句中的有问题符号
724 /// </summary>
725 public static string ChkSQL(string str)
726 {
727 return (str == null) ? "" : str.Replace("\'", "\'\'");
728 }
729 #endregion
730
731 #region 替换手机号和邮箱中间几位
732 /// <summary>
733 /// 替换手机号中间四位为*
734 /// </summary>
735 /// <param name="phoneNo"></param>
736 /// <returns></returns>
737 public static string ReturnPhoneNO(string phoneNo)
738 {
739 Regex re = new Regex(@"(\d{3})(\d{4})(\d{4})", RegexOptions.None);
740 phoneNo = re.Replace(phoneNo, "$1****$3");
741 return phoneNo;
742 }
743
744 /// <summary>
745 /// 替换邮箱中间几位为*号
746 /// </summary>
747 /// <param name="Email"></param>
748 /// <returns></returns>
749 public static string ReturnEmail(string Email)
750 {
751 Regex re = new Regex(@"\w{3}(?=@\w+?.\S+)", RegexOptions.None);
752 Email = re.Replace(Email, "****");
753 return Email;
754 }
755 #endregion
756 }
757 }