1 public sealed class StringTool
2 {
3 /// <summary>
4 /// 将txt文件读入字符串
5 /// </summary>
6 /// <param name="aPath"></param>
7 /// <returns></returns>
8 public static string ReadTextFile(string aPath)
9 {
10 string text = "";
11 using (TextReader tr = new StreamReader(aPath))
12 {
13 text = tr.ReadToEnd();
14 }
15 return text;
16 }
17
18 /// <summary>
19 /// 将16进行编码的字符串写入到指定的文件路径
20 /// </summary>
21 /// <param name="aPath"></param>
22 /// <param name="aText"></param>
23 public static void WriteTextFile(string aPath, string aText)
24 {
25 using (TextWriter tw = new StreamWriter(aPath))
26 {
27 tw.Write(aText);
28 }
29 }
30
31 /// <summary>
32 /// 序列化DataTable，
33 /// </summary>
34 /// <param name="aTable">需要序列化的DataTable</param>
35 /// <returns>成功返回非空字符串</returns>
36 public static string SerializerToXml(DataTable aTable)
37 {
38 StringBuilder sb = new StringBuilder();
39 if (aTable == null)
40 return "";
41
42 System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(System.Data.DataTable));
43 System.Xml.XmlWriter writer = System.Xml.XmlWriter.Create(sb);
44 serializer.Serialize(writer, aTable);
45
46 return sb.ToString();
47 }
48
49 /// <summary>
50 /// 反序列化DataTable表
51 /// </summary>
52 /// <param name="aXmlData">需要反序列化的DataTable的数据</param>
53 /// <returns>成功返回DataTable，失败返回null</returns>
54 public static DataTable DeSerializerFromXml(string aXmlData)
55 {
56 if (string.IsNullOrEmpty(aXmlData))
57 return null;
58
59 System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(System.Data.DataTable));
60 return (DataTable)serializer.Deserialize(new StringReader(aXmlData));
61 }
62
63 /*
64 // 字符串进行16进制编码[decodeSTR]，因为编码后位数不等，为了节约空间不进行等长操作，所以并以","分隔
65 // 与 StringTool.cs的函数相对应
66 function EncodeSTR(str) {
67 var t = "";
68 for (var x = 0; x < str.length; x++) {
69 a = str.charCodeAt(x);
70 if (x != 0) {
71 t += ',';
72 }
73 t += a.toString(16).toUpperCase();
74 }
75 return t;
76 }
77 //字符串[以","分隔]进行16进制解码,编码用[encodeSTR]
78 // 与 StringTool.cs的函数相对应
79 function DecodeSTR(str) {
80 var a1 = str.split(',');
81 for (var x = 0; x < a1.length; x++) {
82 a1[x] = String.fromCharCode(parseInt(a1[x], 16).toString(10));
83 }
84 return a1.join('');
85 }
86 */
87 /// <summary>
88 /// 字符串转为用,分隔的16进制字符串 解码用[decodeSTR] 与 StringTool.js的函数相对应
89 /// </summary>
90 /// <param name="str">字符串</param>
91 /// <param name="uppercase">大小写</param>
92 /// <returns>失败返回空字符串</returns>
93 static public string EncodeSTR(string str, bool uppercase = true)
94 {
95 if (string.IsNullOrEmpty(str))
96 return "";
97 Char[] aa = str.ToCharArray();
98 StringBuilder sb = new StringBuilder();
99 string strFormat = "{0:" + (uppercase == true ? "X" : "x") + "}";
100 for (int i = 0; i < str.Length; i++)
101 {
102 sb.Append(String.Format(strFormat, Char.ConvertToUtf32(str, i)));
103 sb.Append(",");
104 }
105 if (sb.Length > 0)
106 sb.Remove(sb.Length - 1, 1);
107 return sb.ToString();
108 }
109
110 /// <summary>
111 /// 用,分隔的16进制字符串转为字符串 编码用[EncodeSTR] 与 StringTool.js的函数相对应
112 /// </summary>
113 /// <param name="str">用,分隔的16进制字符串</param>
114 /// <returns>失败返回空字符串</returns>
115 static public string DecodeSTR(string str)
116 {
117 if (string.IsNullOrEmpty(str))
118 return "";
119 string[] aHexString = str.Split(new char[] { ',' });
120 StringBuilder sb = new StringBuilder();
121 for (int i = 0; i < aHexString.Length; i++)
122 {
123 sb.Append(Char.ConvertFromUtf32(Convert.ToInt32(aHexString[i], 16)));
124 }
125 return sb.ToString();
126 }
127
128 /// <summary>
129 /// 将字符串转为16进制字符串，并进行了异或加密
130 /// </summary>
131 /// <param name="aStr"></param>
132 /// <returns></returns>
133 public static string StringToHexString(string aStr)
134 {
135 if (string.IsNullOrEmpty(aStr))
136 return "";
137 byte[] b = Encoding.Unicode.GetBytes(EncryptXOR(aStr));
138 return ArrayToHexString(b);
139 }
140
141 /// <summary>
142 /// 将16进制字符串转为字符串,并进行了异或解密
143 /// </summary>
144 /// <param name="aStr"></param>
145 /// <returns></returns>
146 public static string HexStringToString(string aStr)
147 {
148 if (string.IsNullOrEmpty(aStr))
149 return "";
150 byte[] b = HexStringToArray(aStr);
151 return DecryptXOR(Encoding.Unicode.GetString(b));
152 }
153
154 /// <summary>
155 /// 字节数组到16进制字符串
156 /// </summary>
157 /// <param name="array"></param>
158 /// <param name="uppercase">大小写</param>
159 /// <returns>失败返回空字符串</returns>
160 ///
161 static public string ArrayToHexString(byte[] array, bool uppercase = true)
162 {
163 if (array == null || array.Length < 1) return "";
164 string format = "x2";
165 if (uppercase) format = "X2";
166 StringBuilder sb = new StringBuilder();
167 foreach (byte b in array) sb.Append(b.ToString(format));
168 return sb.ToString();
169 }
170
171 /// <summary>
172 /// 将16进制字符串转为字节数组
173 /// </summary>
174 /// <param name="aHexString"></param>
175 /// <param name="uppercase"></param>
176 /// <returns></returns>
177 static public byte[] HexStringToArray(string aHexString, bool uppercase = true)
178 {
179 if (string.IsNullOrEmpty(aHexString))
180 return null;
181 int count = aHexString.Length / 2;
182 byte[] b = new byte[count];
183 for (int i = 0; i < count; i++)
184 {
185 string s = aHexString.Substring(i * 2, 2);
186 b[i] = byte.Parse(s, System.Globalization.NumberStyles.HexNumber);
187 }
188
189 return b;
190 }
191
192 /// <summary>
193 /// 在unicode 字符串中，中文的范围是在4E00..9FFF
194 // 通过对字符的unicode编码进行判断来确定字符是否为中文。
195 /// </summary>
196 /// <param name="word"></param>
197 /// <returns></returns>
198 static public bool IsChineseLetter(string word)
199 {
200 int code = 0;
201 int chfrom = Convert.ToInt32("4e00", 16); //范围（0x4e00～0x9fff）转换成int（chfrom～chend）
202 int chend = Convert.ToInt32("9fff", 16);
203 if (word != "")
204 {
205 code = Char.ConvertToUtf32(word, 0); //获得字符word中指定索引index处字符unicode编码
206 if (code >= chfrom && code <= chend)
207 return true; //当code在中文范围内返回true
208 else
209 return false; //当code不在中文范围内返回false
210 }
211 return false;
212 }
213
214 /// <summary>
215 /// 判断句子中是否含有中文
216 /// </summary>
217 /// <param >字符串</param>
218 /// <returns></returns>
219 static public bool WordsInChinese(string aStr)
220 {
221 Regex rx = new Regex("^[\u4e00-\u9fa5]$");
222 for (int i = 0; i < aStr.Length; i++)
223 {
224 if (rx.IsMatch(aStr[i].ToString()))
225 return true;
226 }
227 return false;
228 }
229
230 /// <summary>
231 /// 给定一个字符串，判断其是否只包含有汉字
232 /// </summary>
233 /// <param name="aStr"></param>
234 /// <returns></returns>
235 static public bool IsOnlyContainsChinese(string aStr)
236 {
237 char[] words = aStr.ToCharArray();
238 foreach (char word in words)
239 {
240 if (IsGBCode(word.ToString()) || IsGBKCode(word.ToString())) // it is a GB2312 or GBK chinese word
241 continue;
242 else
243 return false;
244 }
245 return true;
246 }
247
248 /// <summary>
249 /// 判断一个word是否为GB2312编码的汉字
250 /// </summary>
251 /// <param name="word"></param>
252 /// <returns></returns>
253 static public bool IsGBCode(string word)
254 {
255 byte[] bytes = Encoding.GetEncoding("GB2312").GetBytes(word);
256 if (bytes.Length <= 1) // if there is only one byte, it is ASCII code or other code
257 return false;
258 else
259 {
260 byte byte1 = bytes[0];
261 byte byte2 = bytes[1];
262 if (byte1 >= 176 && byte1 <= 247 && byte2 >= 160 && byte2 <= 254) //判断是否是GB2312
263 return true;
264 else
265 return false;
266 }
267 }
268
269 /// <summary>
270 /// 判断一个word是否为GBK编码的汉字
271 /// </summary>
272 /// <param name="word"></param>
273 /// <returns></returns>
274 static public bool IsGBKCode(string word)
275 {
276 byte[] bytes = Encoding.GetEncoding("GBK").GetBytes(word.ToString());
277 if (bytes.Length <= 1) // if there is only one byte, it is ASCII code
278 return false;
279 else
280 {
281 byte byte1 = bytes[0];
282 byte byte2 = bytes[1];
283 if (byte1 >= 129 && byte1 <= 254 && byte2 >= 64 && byte2 <= 254) //判断是否是GBK编码
284 return true;
285 else
286 return false;
287 }
288 }
289
290 /// <summary>
291 /// 判断一个word是否为Big5编码的汉字
292 /// </summary>
293 /// <param name="word"></param>
294 /// <returns></returns>
295 static public bool IsBig5Code(string word)
296 {
297 byte[] bytes = Encoding.GetEncoding("Big5").GetBytes(word.ToString());
298 if (bytes.Length <= 1) // if there is only one byte, it is ASCII code
299 return false;
300 else
301 {
302 byte byte1 = bytes[0];
303 byte byte2 = bytes[1];
304 if ((byte1 >= 129 && byte1 <= 254) && ((byte2 >= 64 && byte2 <= 126) || (byte2 >= 161 && byte2 <= 254))) //判断是否是Big5编码
305 return true;
306 else
307 return false;
308 }
309 }
310
311 /// <summary>
312 /// 对字符串进行简单的异或加密
313 /// </summary>
314 /// <param name="aStr"></param>
315 /// <param name="aXor"></param>
316 /// <returns>失败返回空字符串</returns>
317 static public string EncryptXOR(string aStr, byte aXor = 0x11)
318 {
319 if (String.IsNullOrEmpty(aStr))
320 return "";
321 byte[] bb = Encoding.Unicode.GetBytes(aStr);
322 for (int i = 0; i < bb.Length; i++)
323 bb[i] ^= aXor;
324 return Encoding.Unicode.GetString(bb);
325 }
326
327 /// <summary>
328 /// 对字符串进行简单的异或解密
329 /// </summary>
330 /// <param name="aStr"></param>
331 /// <param name="aXor"></param>
332 /// <returns>失败返回空字符串</returns>
333 static public string DecryptXOR(string aStr, byte aXor = 0x11)
334 {
335 if (String.IsNullOrEmpty(aStr))
336 return "";
337 byte[] bb = Encoding.Unicode.GetBytes(aStr);
338 for (int i = 0; i < bb.Length; i++)
339 bb[i] ^= aXor;
340 return Encoding.Unicode.GetString(bb);
341 }
342
343 /// <summary>
344 /// 获得字符串中开始和结束字符串中间得字符
345 /// </summary>
346 /// <param name="str">字符串</param>
347 /// <param name="s">开始</param>
348 /// <param name="e">结束</param>
349 /// </summary>
350 public static string GetSubString(string str, string s, string e)
351 {
352 Regex rg = new Regex("(?<=(" + s + "))[.\\s\\S]*?(?=(" + e + "))", RegexOptions.Multiline | RegexOptions.Singleline);
353 return rg.Match(str).Value;
354 }
355
356 /// <summary>
357 /// 从最后一位验证前面17位的18位身份证号码
358 /// </summary>
359 /// <param name="id"></param>
360 /// <returns></returns>
361 public static bool CheckCardId(string id)
362 {
363 /* 身份证号码的验证及15位升18位算法
364 18位身份证标准在国家质量技术监督局于1999年7月1日实施的GB11643-1999《公民身份号码》中做了明确的规定。 GB11643-1999《公民身份号码》为GB11643-1989《社会保障号码》的修订版，其中指出将原标准名称"社会保障号码"更名为"公民身份号码"，另外GB11643-1999《公民身份号码》从实施之日起代替GB11643-1989。GB11643-1999《公民身份号码》主要内容如下：
365 一、范围
366 该标准规定了公民身份号码的编码对象、号码的结构和表现形式，使每个编码对象获得一个唯一的、不变的法定号码。
367 二、编码对象
368 公民身份号码的编码对象是具有*国籍的公民。
369 三、号码的结构和表示形式
370 1、号码的结构
371 公民身份号码是特征组合码，由十七位数字本体码和一位校验码组成。排列顺序从左至右依次为：六位数字地址码，八位数字出生日期码，三位数字顺序码和一位数字校验码。
372 2、地址码
373 表示编码对象常住户口所在县(市、旗、区)的行政区划代码，按GB/T2260的规定执行。
374 3、出生日期码
375 表示编码对象出生的年、月、日，按GB/T7408的规定执行，年、月、日代码之间不用分隔符。
376 4、顺序码
377 表示在同一地址码所标识的区域范围内，对同年、同月、同日出生的人编定的顺序号，顺序码的奇数分配给男性，偶数分配给女性。
378 5、校验码
379 （1）十七位数字本体码加权求和公式
380 S = Sum(Ai * Wi),先对前17位数字的权求和
381 Ai:表示第i位置上的身份证号码数字值
382 Wi:表示第i位置上的加权因子
383 Wi: 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2
384 （2）计算模 Y = mod(S, 11)
385 （3）通过模得到对应的校验码
386 Y: 0 1 2 3 4 5 6 7 8 9 10
387 校验码: 1 0 X 9 8 7 6 5 4 3 2
388 四、举例如下：
389 北京市朝阳区: 11010519491231002X
390 广东省汕头市: 440524188001010014
391 */
392
393 int[] wQuan = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 };
394 string checkWei = "10X98765432";
395
396 string number17 = id.Substring(0, 17);
397 string number18 = id.Substring(17);
398
399 int sum = 0;
400 for (int i = 0; i < 17; i++)
401 sum = sum + Convert.ToInt32(number17[i].ToString()) * wQuan[i];
402
403 int mod = sum % 11;
404 string result = checkWei[mod].ToString();
405 if (number18.Equals(result, StringComparison.OrdinalIgnoreCase))
406 {
407 return true;
408 }
409 else
410 {
411 return false;
412 }
413 }
414
415 /// <summary>
416 /// 生成一个序列号,根据Guid生成，最短1位，最长33位，默认是4位
417 /// </summary>
418 /// <param name="aLength"></param>
419 /// <returns></returns>
420 public static string CreateSerialNumber(int aLength = 4)
421 {
422 if (aLength < 1)
423 aLength = 1;
424 if (aLength > 33)
425 aLength = 33;
426
427 string str = string.Empty;
428 string codeStr = string.Empty;
429 string guidStr = Guid.NewGuid().ToString().Replace("-", "");
430 int guidStrLen = guidStr.Length;
431 Random rnd = new Random(int.Parse(DateTime.Now.ToString("MMddHHmmsss")));
432
433 for (int i = 0; i < aLength; i++)
434 {
435 int index = rnd.Next(0, guidStrLen - 1);
436 str += guidStr.Substring(index, 1);
437 }
438
439 return str.ToUpper();
440 }
441
442 /// <summary>
443 /// 反转字符串
444 /// </summary>
445 /// <param name="aString"></param>
446 /// <returns></returns>
447 public static string ReverseString(string aString)
448 {
449 if (string.IsNullOrEmpty(aString))
450 return "";
451 Char[] LS_Str = aString.ToCharArray();
452 Array.Reverse(LS_Str);
453
454 return new String(LS_Str);//反转字符串
455 }
456
457 /// <summary>
458 /// 全角转半角
459 /// </summary>
460 /// <param name="aString"></param>
461 /// <returns></returns>
462 public static string QjToBj(string aString)
463 {
464 string QJstr = aString;
465 char[] c = QJstr.ToCharArray();
466 for (int i = 0; i < c.Length; i++)
467 {
468 byte[] b = System.Text.Encoding.Unicode.GetBytes(c, i, 1);
469 if (b.Length == 2)
470 {
471 if (b[1] == 255)
472 {
473 b[0] = (byte)(b[0] + 32);
474 b[1] = 0;
475 c[i] = System.Text.Encoding.Unicode.GetChars(b)[0];
476 }
477 }
478 }
479 string strNew = new string(c);
480 return strNew;
481 }
482
483 /// <summary>
484 /// 获得汉字拼音的的第一个字母
485 /// </summary>
486 /// <param name="aText"></param>
487 /// <returns></returns>
488 static public string GetChineseSpellFirstLetter(string aText)
489 {
490 int len = aText.Length;
491 string myStr = "";
492 for (int i = 0; i < len; i++)
493 {
494 myStr += GetSpell(aText[i]);
495 }
496 return myStr.ToLower();
497 }
498
499 /// <summary>
500 /// 利用汉字在计算机里面的编码来的到汉字的拼音。
501 /// </summary>
502 /// <param name="aChar"></param>
503 /// <returns></returns>
504 static public string GetSpell(char aChar)
505 {
506 byte[] arrCN = Encoding.Default.GetBytes(aChar.ToString());
507 if (arrCN.Length > 1)
508 {
509 int area = (short)arrCN[0];
510 int pos = (short)arrCN[1];
511 int code = (area << 8) + pos;
512 int[] areacode = { 45217, 45253, 45761, 46318, 46826, 47010, 47297, 47614, 48119, 48119, 49062, 49324, 49896, 50371, 50614, 50622, 50906, 51387, 51446, 52218, 52698, 52698, 52698, 52980, 53689, 54481 };
513 for (int i = 0; i < 26; i++)
514 {
515 int max = 55290;
516 if (i != 25) max = areacode[i + 1];
517 if (areacode[i] <= code && code < max)
518 {
519 return Encoding.Default.GetString(new byte[] { (byte)(65 + i) });
520 }
521 }
522 return aChar.ToString();
523 }
524 else
525 return aChar.ToString();
526 }
527 }
