很早以前写的一个正则表达式验证工具类，包含了一些常见的校验和支持自定义的正则表达式匹配，可以选择完全匹配，也可以获取所有匹配项。曾用它仿造Eclispe下的正则表达式插件写过一个工具。因为最近突然有几个朋友都在问这方面的问题，干脆就把代码贴出来好了。
using System;
02.using System.Collections;
03.using System.Text.RegularExpressions;
04.
05.namespace Xrinehart.Framework.Common.Validate
06.{
07. /**//// <summary>
08. /// RegularMatch 的摘要说明。
09. /// </summary>
10. public class RegularMatch
11. {
12. private string _String;
13. private bool _IsEntirety;
14.
15. /**//// <summary>
16. /// 可以进行判断的类型
17. /// </summary>
18. public enum Operation
19. {
20. Byte, SByte, Int16, Int32, Int64, Single, Double, Boolean, Char, Decimal, DateTime, Date, Time,
21. EMail, URL, ChinaPhone, ChineseWord, ChinesePostalCode, Number, StringModel_01, StringModel_02, WideWord, NarrowWord, IPAddress,
22. ChineseMobile, ChineseID
23. };
24.
25. public RegularMatch() { }
26.
27. 用于判断字符串是否是对应类型（默认为包含匹配）#region 用于判断字符串是否是对应类型（默认为包含匹配）
28. public bool IsAccordType(string strVerifyString, Operation op)
29. {
30. return IsAccordType(strVerifyString, op, false);
31. }
32. #endregion
33.
34. 用于判断字符串是否是对应类型（或是否包含对应类型的字符）#region 用于判断字符串是否是对应类型（或是否包含对应类型的字符）
35. /**//// <summary>
36. /// 用于判断字符串是否是对应类型
37. /// </summary>
38. /// <param name="strVerifyString">String，需要判断的字符串</param>
39. /// <param name="op">Operation枚举，用于选择需要进行的操作</param>
40. /// <param name="IsEntirety">Boolean，判断是完全匹配还是包含匹配模式（仅适用于非类型判断时）</param>
41. /// <returns></returns>
42. public bool IsAccordType(string strVerifyString, Operation op, bool IsEntirety)
43. {
44. _String = strVerifyString;
45. _IsEntirety = IsEntirety;
46.
47. switch (op)
48. {
49. case Operation.Byte:
50. {
51. return IsByte();
52. }
53. case Operation.SByte:
54. {
55. return IsSByte();
56. }
57. case Operation.Int16:
58. {
59. return IsInt16();
60. }
61. case Operation.Int32:
62. {
63. return IsInt32();
64. }
65. case Operation.Int64:
66. {
67. return IsInt64();
68. }
69. case Operation.Single:
70. {
71. return IsSingle();
72. }
73. case Operation.Double:
74. {
75. return IsDouble();
76. }
77. case Operation.Boolean:
78. {
79. return IsBoolean();
80. }
81. case Operation.Char:
82. {
83. return IsChar();
84. }
85. case Operation.Decimal:
86. {
87. return IsDecimal();
88. }
89. case Operation.DateTime:
90. {
91. return IsDateTime();
92. }
93. case Operation.Date:
94. {
95. return IsDate();
96. }
97. case Operation.Time:
98. {
99. return IsTime();
100. }
101. case Operation.IPAddress:
102. {
103. return IsIPAddress();
104. }
105. case Operation.ChinaPhone:
106. {
107. return IsChinaPhone();
108. }
109. case Operation.ChinesePostalCode:
110. {
111. return IsChinesePostalCode();
112. }
113. case Operation.ChineseMobile:
114. {
115. return IsChineseMobile();
116. }
117. case Operation.EMail:
118. {
119. return IsEmail();
120. }
121. case Operation.URL:
122. {
123. return IsURL();
124. }
125. case Operation.ChineseWord:
126. {
127. return IsChineseWord();
128. }
129. case Operation.Number:
130. {
131. return IsNumber();
132. }
133. case Operation.StringModel_01:
134. {
135. return IsStringModel_01();
136. }
137. case Operation.StringModel_02:
138. {
139. return IsStringModel_02();
140. }
141. case Operation.WideWord:
142. {
143. return IsWideWord();
144. }
145. case Operation.NarrowWord:
146. {
147. return IsNarrowWord();
148. }
149. case Operation.ChineseID:
150. {
151. return IsChineseID();
152. }
153. default:
154. {
155. return false;
156. }
157. }
158. }
159. #endregion
160.
161. 具体验证方法#region 具体验证方法
162.
163. 是否Byte类型（8 位的无符号整数）： 0 和 255 之间的无符号整数#region 是否Byte类型（8 位的无符号整数）： 0 和 255 之间的无符号整数
164. /**//// <summary>
165. /// 是否Byte类型（8 位的无符号整数）： 0 和 255 之间的无符号整数
166. /// </summary>
167. /// <returns>Boolean</returns>
168. protected bool IsByte()
169. {
170. try
171. {
172. Byte.Parse(_String);
173. }
174. catch
175. {
176. return false;
177. }
178. return true;
179. }
180. #endregion
181.
182. 是否SByte类型（8 位的有符号整数）： -128 到 +127 之间的整数#region 是否SByte类型（8 位的有符号整数）： -128 到 +127 之间的整数
183. /**//// <summary>
184. /// 是否SByte类型（8 位的有符号整数）： -128 到 +127 之间的整数
185. /// </summary>
186. /// <returns>Boolean</returns>
187. protected bool IsSByte()
188. {
189. try
190. {
191. SByte.Parse(_String);
192. }
193. catch
194. {
195. return false;
196. }
197. return true;
198. }
199. #endregion
200.
201. 是否Int16类型（16 位的有符号整数）： -32768 到 +32767 之间的有符号整数#region 是否Int16类型（16 位的有符号整数）： -32768 到 +32767 之间的有符号整数
202. /**//// <summary>
203. /// 是否Int16类型（16 位的有符号整数）： -32768 到 +32767 之间的有符号整数
204. /// </summary>
205. /// <returns>Boolean</returns>
206. protected bool IsInt16()
207. {
208. try
209. {
210. Int16.Parse(_String);
211. }
212. catch
213. {
214. return false;
215. }
216. return true;
217. }
218. #endregion
219.
220. 是否Int32类型（32 位的有符号整数）：-2,147,483,648 到 +2,147,483,647 之间的有符号整数#region 是否Int32类型（32 位的有符号整数）：-2,147,483,648 到 +2,147,483,647 之间的有符号整数
221. /**//// <summary>
222. /// 是否Int32类型（32 位的有符号整数）：-2,147,483,648 到 +2,147,483,647 之间的有符号整数
223. /// </summary>
224. /// <returns>Boolean</returns>
225. protected bool IsInt32()
226. {
227. try
228. {
229. Int32.Parse(_String);
230. }
231. catch
232. {
233. return false;
234. }
235. return true;
236. }
237. #endregion
238.
239. 是否Int64类型（64 位的有符号整数）： -9,223,372,036,854,775,808 到 +9,223,372,036,854,775,807 之间的整数#region 是否Int64类型（64 位的有符号整数）： -9,223,372,036,854,775,808 到 +9,223,372,036,854,775,807 之间的整数
240. /**//// <summary>
241. /// 是否Int64类型（64 位的有符号整数）： -9,223,372,036,854,775,808 到 +9,223,372,036,854,775,807 之间的整数
242. /// </summary>
243. /// <returns>Boolean</returns>
244. protected bool IsInt64()
245. {
246. try
247. {
248. Int64.Parse(_String);
249. }
250. catch
251. {
252. return false;
253. }
254. return true;
255. }
256. #endregion
257.
258. 是否Single类型（单精度（32 位）浮点数字）： -3.402823e38 和 +3.402823e38 之间的单精度 32 位数字#region 是否Single类型（单精度（32 位）浮点数字）： -3.402823e38 和 +3.402823e38 之间的单精度 32 位数字
259. /**//// <summary>
260. /// 是否Single类型（单精度（32 位）浮点数字）： -3.402823e38 和 +3.402823e38 之间的单精度 32 位数字
261. /// </summary>
262. /// <returns>Boolean</returns>
263. protected bool IsSingle()
264. {
265. try
266. {
267. Single.Parse(_String);
268. }
269. catch
270. {
271. return false;
272. }
273. return true;
274. }
275. #endregion
276.
277. 是否Double类型（单精度（64 位）浮点数字）： -1.79769313486232e308 和 +1.79769313486232e308 之间的双精度 64 位数字#region 是否Double类型（单精度（64 位）浮点数字）： -1.79769313486232e308 和 +1.79769313486232e308 之间的双精度 64 位数字
278. /**//// <summary>
279. /// 是否Double类型（单精度（64 位）浮点数字）： -1.79769313486232e308 和 +1.79769313486232e308 之间的双精度 64 位数字
280. /// </summary>
281. /// <returns>Boolean</returns>
282. protected bool IsDouble()
283. {
284. try
285. {
286. Double.Parse(_String);
287. }
288. catch
289. {
290. return false;
291. }
292. return true;
293. }
294. #endregion
295.
296. 是否Boolean类型（布尔值）：true 或 false#region 是否Boolean类型（布尔值）：true 或 false
297. /**//// <summary>
298. /// 是否Double类型（单精度（64 位）浮点数字）： -1.79769313486232e308 和 +1.79769313486232e308 之间的双精度 64 位数字
299. /// </summary>
300. /// <returns>Boolean</returns>
301. protected bool IsBoolean()
302. {
303. try
304. {
305. Boolean.Parse(_String);
306. }
307. catch
308. {
309. return false;
310. }
311. return true;
312. }
313. #endregion
314.
315. 是否Char类型（Unicode（16 位）字符）：该 16 位数字的值范围为从十六进制值 0x0000 到 0xFFFF#region 是否Char类型（Unicode（16 位）字符）：该 16 位数字的值范围为从十六进制值 0x0000 到 0xFFFF
316. /**//// <summary>
317. /// 是否Char类型（Unicode（16 位）字符）：该 16 位数字的值范围为从十六进制值 0x0000 到 0xFFFF
318. /// </summary>
319. /// <returns>Boolean</returns>
320. protected bool IsChar()
321. {
322. try
323. {
324. Char.Parse(_String);
325. }
326. catch
327. {
328. return false;
329. }
330. return true;
331. }
332. #endregion
333.
334. 是否Char类型（96 位十进制值）：从正 79,228,162,514,264,337,593,543,950,335 到负 79,228,162,514,264,337,593,543,950,335 之间的十进制数#region 是否Char类型（96 位十进制值）：从正 79,228,162,514,264,337,593,543,950,335 到负 79,228,162,514,264,337,593,543,950,335 之间的十进制数
335. /**//// <summary>
336. /// 是否Char类型（96 位十进制值）：从正 79,228,162,514,264,337,593,543,950,335 到负 79,228,162,514,264,337,593,543,950,335 之间的十进制数
337. /// </summary>
338. /// <returns>Boolean</returns>
339. protected bool IsDecimal()
340. {
341. try
342. {
343. Decimal.Parse(_String);
344. }
345. catch
346. {
347. return false;
348. }
349. return true;
350. }
351. #endregion
352.
353. 是否DateTime类型（表示时间上的一刻）： 范围在公元（基督纪元）0001 年 1 月 1 日午夜 12:00:00 到公元 (C.E.) 9999 年 12 月 31 日晚上 11:59:59 之间的日期和时间#region 是否DateTime类型（表示时间上的一刻）： 范围在公元（基督纪元）0001 年 1 月 1 日午夜 12:00:00 到公元 (C.E.) 9999 年 12 月 31 日晚上 11:59:59 之间的日期和时间
354. /**//// <summary>
355. /// 是否DateTime类型（表示时间上的一刻）： 范围在公元（基督纪元）0001 年 1 月 1 日午夜 12:00:00 到公元 (C.E.) 9999 年 12 月 31 日晚上 11:59:59 之间的日期和时间
356. /// </summary>
357. /// <returns>Boolean</returns>
358. protected bool IsDateTime()
359. {
360. try
361. {
362. DateTime.Parse(_String);
363. }
364. catch
365. {
366. return false;
367. }
368. return true;
369. }
370. #endregion
371.
372. 是否Date类型（表示时间的日期部分）： 范围在公元（基督纪元）0001 年 1 月 1 日 到公元 (C.E.) 9999 年 12 月 31 日之间的日期#region 是否Date类型（表示时间的日期部分）： 范围在公元（基督纪元）0001 年 1 月 1 日 到公元 (C.E.) 9999 年 12 月 31 日之间的日期
373. /**//// <summary>
374. /// 是否Date类型（表示时间的日期部分）： 范围在公元（基督纪元）0001 年 1 月 1 日 到公元 (C.E.) 9999 年 12 月 31 日之间的日期
375. /// </summary>
376. /// <returns>Boolean</returns>
377. protected bool IsDate()
378. {
379. DateTime Value;
380. try
381. {
382. Value = DateTime.Parse(_String);
383. }
384. catch
385. {
386. return false;
387. }
388. if (Value.Date.ToString() == _String)
389. {
390. return true;
391. }
392. else
393. {
394. return false;
395. }
396. }
397. #endregion
398.
399. 是否Time类型（表示时间部分HHMMSS）： 范围在夜 12:00:00 到晚上 11:59:59 之间的时间#region 是否Time类型（表示时间部分HHMMSS）： 范围在夜 12:00:00 到晚上 11:59:59 之间的时间
400. /**//// <summary>
401. /// 是否Time类型（表示时间部分HHMMSS）： 范围在夜 12:00:00 到晚上 11:59:59 之间的时间
402. /// </summary>
403. /// <returns>Boolean</returns>
404. protected bool IsTime()
405. {
406. DateTime Value;
407. try
408. {
409. Value = DateTime.Parse(_String);
410. }
411. catch
412. {
413. return false;
414. }
415. if (Value.Year == 1 && Value.Month == 1 && Value.Day == 1)
416. {
417. return true;
418. }
419. else
420. {
421. return false;
422. }
423. }
424. #endregion
425.
426. 是否IPAddress类型（IPv4 的情况下使用以点分隔的四部分表示法格式表示，IPv6 的情况下使用冒号与十六进制格式表示）#region 是否IPAddress类型（IPv4 的情况下使用以点分隔的四部分表示法格式表示，IPv6 的情况下使用冒号与十六进制格式表示）
427. /**//// <summary>
428. /// 是否IPAddress类型（IPv4 的情况下使用以点分隔的四部分表示法格式表示，IPv6 的情况下使用冒号与十六进制格式表示）
429. /// </summary>
430. /// <returns>Boolean</returns>
431. protected bool IsIPAddress()
432. {
433. try
434. {
435. System.Net.IPAddress.Parse(_String);
436. }
437. catch
438. {
439. return false;
440. }
441. return true;
442. }
443. #endregion
444.
445. 是否中国电话号码类型（XXX/XXXX-XXXXXXX/XXXXXXXX (/d{3,4})-?/d{7,8}）：判断是否是（区号：3或4位）-（电话号码：7或8位）#region 是否中国电话号码类型（XXX/XXXX-XXXXXXX/XXXXXXXX (/d{3,4})-?/d{7,8}）：判断是否是（区号：3或4位）-（电话号码：7或8位）
446. /**//// <summary>
447. /// 是否中国电话号码类型（XXX/XXXX-XXXXXXX/XXXXXXXX (/d{3,4})-?/d{7,8}）：判断是否是（区号：3或4位）-（电话号码：7或8位）
448. /// </summary>
449. /// <returns>Boolean</returns>
450. protected bool IsChinaPhone()
451. {
452. ArrayList aryResult = new ArrayList();
453. return CommRegularMatch(_String, @"(/d{3,4})-?/d{7,8}", RegexOptions.None, ref aryResult, _IsEntirety);
454. }
455. #endregion
456.
457. 是否中国邮政编码（6位数字 /d{6}）#region 是否中国邮政编码（6位数字 /d{6}）
458. /**//// <summary>
459. /// 是否中国邮政编码（6位数字 /d{6}）
460. /// </summary>
461. /// <returns>Boolean</returns>
462. protected bool IsChinesePostalCode()
463. {
464. ArrayList aryResult = new ArrayList();
465. return CommRegularMatch(_String, @"/d{6}", RegexOptions.None, ref aryResult, _IsEntirety);
466. }
467. #endregion
468.
469. 是否中国移动电话号码（13开头的总11位数字 13/d{9}）#region 是否中国移动电话号码（13开头的总11位数字 13/d{9}）
470. /**//// <summary>
471. /// 是否中国移动电话号码（13开头的总11位数字 13/d{9}）
472. /// </summary>
473. /// <returns>Boolean</returns>
474. protected bool IsChineseMobile()
475. {
476. ArrayList aryResult = new ArrayList();
477. return CommRegularMatch(_String, @"13/d{9}", RegexOptions.None, ref aryResult, _IsEntirety);
478. }
479. #endregion
480.
481. 是否EMail类型（XXX@XXX.XXX /w+([-+.]/w+)*@/w+([-.]/w+)*/./w+([-.]/w+)*）#region 是否EMail类型（XXX@XXX.XXX /w+([-+.]/w+)*@/w+([-.]/w+)*/./w+([-.]/w+)*）
482. /**//// <summary>
483. /// 是否EMail类型（XXX@XXX.XXX /w+([-+.]/w+)*@/w+([-.]/w+)*/./w+([-.]/w+)*）
484. /// </summary>
485. /// <returns>Boolean</returns>
486. protected bool IsEmail()
487. {
488. ArrayList aryResult = new ArrayList();
489. return CommRegularMatch(_String, @"/w+([-+.]/w+)*@/w+([-.]/w+)*/./w+([-.]/w+)*", RegexOptions.None, ref aryResult, _IsEntirety);
490. }
491. #endregion
492.
493. 是否Internet URL地址类型（http://）#region 是否Internet URL地址类型（http://）
494. /**//// <summary>
495. /// 是否Internet URL地址类型（http://）
496. /// </summary>
497. /// <returns>Boolean</returns>
498. protected bool IsURL()
499. {
500. ArrayList aryResult = new ArrayList();
501. return CommRegularMatch(_String, @"http://([/w-]+/.)+[/w-]+(/[/w- ./?%&=]*)?", RegexOptions.None, ref aryResult, _IsEntirety);
502. }
503. #endregion
504.
505. 是否中文字符（[/u4e00-/u9fa5]）#region 是否中文字符（[/u4e00-/u9fa5]）
506. /**//// <summary>
507. /// 是否中文字符（[/u4e00-/u9fa5]）
508. /// </summary>
509. /// <returns>Boolean</returns>
510. protected bool IsChineseWord()
511. {
512. ArrayList aryResult = new ArrayList();
513. return CommRegularMatch(_String, @"[/u4e00-/u9fa5]", RegexOptions.None, ref aryResult, _IsEntirety);
514. }
515. #endregion
516.
517. 是否是数字（0到9的数字[/d]+）：不包括符号"."和"-"#region 是否是数字（0到9的数字[/d]+）：不包括符号"."和"-"
518. /**//// <summary>
519. /// 是否是数字（0到9的数字[/d]+）：不包括符号"."和"-"
520. /// </summary>
521. /// <returns>Boolean</returns>
522. protected bool IsNumber()
523. {
524. ArrayList aryResult = new ArrayList();
525. return CommRegularMatch(_String, @"[/d]+", RegexOptions.None, ref aryResult, _IsEntirety);
526. }
527. #endregion
528.
529. 是否只包含数字，英文和下划线（[/w]+）#region 是否只包含数字，英文和下划线（[/w]+）
530. /**//// <summary>
531. /// 是否只包含数字，英文和下划线（[/w]+）
532. /// </summary>
533. /// <returns>Boolean</returns>
534. protected bool IsStringModel_01()
535. {
536. ArrayList aryResult = new ArrayList();
537. return CommRegularMatch(_String, @"[/w]+", RegexOptions.None, ref aryResult, _IsEntirety);
538. }
539. #endregion
540.
541. 是否大写首字母的英文字母（[A-Z][a-z]+）#region 是否大写首字母的英文字母（[A-Z][a-z]+）
542. /**//// <summary>
543. /// 是否大写首字母的英文字母（[A-Z][a-z]+）
544. /// </summary>
545. /// <returns>Boolean</returns>
546. protected bool IsStringModel_02()
547. {
548. ArrayList aryResult = new ArrayList();
549. return CommRegularMatch(_String, @"[A-Z][a-z]+", RegexOptions.None, ref aryResult, _IsEntirety);
550. }
551. #endregion
552.
553. 是否全角字符（[^/x00-/xff]）：包括汉字在内#region 是否全角字符（[^/x00-/xff]）：包括汉字在内
554. /**//// <summary>
555. /// 是否全角字符（[^/x00-/xff]）：包括汉字在内
556. /// </summary>
557. /// <returns>Boolean</returns>
558. protected bool IsWideWord()
559. {
560. ArrayList aryResult = new ArrayList();
561. return CommRegularMatch(_String, @"[^/x00-/xff]", RegexOptions.None, ref aryResult, _IsEntirety);
562. }
563. #endregion
564.
565. 是否半角字符（[/x00-/xff]）#region 是否半角字符（[/x00-/xff]）
566. /**//// <summary>
567. /// 是否半角字符（[^/x00-/xff]）：包括汉字在内
568. /// </summary>
569. /// <returns>Boolean</returns>
570. protected bool IsNarrowWord()
571. {
572. ArrayList aryResult = new ArrayList();
573. return CommRegularMatch(_String, @"[/x00-/xff]", RegexOptions.None, ref aryResult, _IsEntirety);
574. }
575. #endregion
576.
577. 是否合法的中国身份证号码#region 是否合法的中国身份证号码
578. protected bool IsChineseID()
579. {
580. if (_String.Length == 15)
581. {
582. _String = CidUpdate(_String);
583. }
584. if (_String.Length == 18)
585. {
586. string strResult = CheckCidInfo(_String);
587. if (strResult == "非法地区" || strResult == "非法生日" || strResult == "非法证号")
588. {
589. return false;
590. }
591. else
592. {
593. return true;
594. }
595. }
596. else
597. {
598. return false;
599. }
600. }
601. #endregion
602.
603. #endregion
604.
605. 通用正则表达式判断函数#region 通用正则表达式判断函数
606. /**//// <summary>
607. /// 通用正则表达式判断函数
608. /// </summary>
609. /// <param name="strVerifyString">String，用于匹配的字符串</param>
610. /// <param name="strRegular">String，正则表达式</param>
611. /// <param name="regOption">RegexOptions，配置正则表达式的选项</param>
612. /// <param name="aryResult">ArrayList，分解的字符串内容</param>
613. /// <param name="IsEntirety">Boolean，是否需要完全匹配</param>
614. /// <returns></returns>
615. public bool CommRegularMatch(string strVerifyString, string strRegular, System.Text.RegularExpressions.RegexOptions regOption, ref System.Collections.ArrayList aryResult, bool IsEntirety)
616. {
617. System.Text.RegularExpressions.Regex r;
618. System.Text.RegularExpressions.Match m;
619.
620. 如果需要完全匹配的处理#region 如果需要完全匹配的处理
621. if (IsEntirety)
622. {
623. strRegular = strRegular.Insert(0, @"/A");
624. strRegular = strRegular.Insert(strRegular.Length, @"/z");
625. }
626. #endregion
627.
628. try
629. {
630. r = new System.Text.RegularExpressions.Regex(strRegular, regOption);
631. }
632. catch (System.Exception e)
633. {
634. throw (e);
635. }
636.
637. for (m = r.Match(strVerifyString); m.Success; m = m.NextMatch())
638. {
639. aryResult.Add(m);
640. }
641.
642. if (aryResult.Count == 0)
643. {
644. return false;
645. }
646. else
647. {
648. return true;
649. }
650. }
651. #endregion
652.
653. 中国身份证号码验证#region 中国身份证号码验证
654. private string CheckCidInfo(string cid)
655. {
656. string[] aCity = new string[] { null, null, null, null, null, null, null, null, null, null, null, "北京", "天津", "河北", "山西", "内蒙古", null, null, null, null, null, "辽宁", "吉林", "黑龙江", null, null, null, null, null, null, null, "上海", "江苏", "浙江", "安微", "福建", "江西", "山东", null, null, null, "河南", "湖北", "湖南", "广东", "广西", "海南", null, null, null, "重庆", "四川", "贵州", "云南", "西藏", null, null, null, null, null, null, "陕西", "甘肃", "青海", "宁夏", "新疆", null, null, null, null, null, "台湾", null, null, null, null, null, null, null, null, null, "香港", "澳门", null, null, null, null, null, null, null, null, "国外" };
657. double iSum = 0;
658. string info = string.Empty;
659. System.Text.RegularExpressions.Regex rg = new System.Text.RegularExpressions.Regex(@"^/d{17}(/d|x)$");
660. System.Text.RegularExpressions.Match mc = rg.Match(cid);
661. if (!mc.Success)
662. {
663. return string.Empty;
664. }
665. cid = cid.ToLower();
666. cid = cid.Replace("x", "a");
667. if (aCity[int.Parse(cid.Substring(0, 2))] == null)
668. {
669. return "非法地区";
670. }
671. try
672. {
673. DateTime.Parse(cid.Substring(6, 4) + " - " + cid.Substring(10, 2) + " - " + cid.Substring(12, 2));
674. }
675. catch
676. {
677. return "非法生日";
678. }
679. for (int i = 17; i >= 0; i--)
680. {
681. iSum += (System.Math.Pow(2, i) % 11) * int.Parse(cid[17 - i].ToString(), System.Globalization.NumberStyles.HexNumber);
682. }
683. if (iSum % 11 != 1)
684. {
685. return ("非法证号");
686. }
687. else
688. {
689. return (aCity[int.Parse(cid.Substring(0, 2))] + "," + cid.Substring(6, 4) + "-" + cid.Substring(10, 2) + "-" + cid.Substring(12, 2) + "," + (int.Parse(cid.Substring(16, 1)) % 2 == 1 ? "男" : "女"));
690. }
691. }
692. #endregion
693.
694. 身份证号码15升级为18位#region 身份证号码15升级为18位
695. private string CidUpdate(string ShortCid)
696. {
697. char[] strJiaoYan = { '1', '0', 'X', '9', '8', '7', '6', '5', '4', '3', '2' };
698. int[] intQuan = { 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2, 1 };
699. string strTemp;
700. int intTemp = 0;
701.
702. strTemp = ShortCid.Substring(0, 6) + "19" + ShortCid.Substring(6);
703. for (int i = 0; i <= strTemp.Length - 1; i++)
704. {
705. intTemp += int.Parse(strTemp.Substring(i, 1)) * intQuan[i];
706. }
707. intTemp = intTemp % 11;
708. return strTemp + strJiaoYan[intTemp];
709. }
710. #endregion
711. }
712.}
更多信息请查看IT技术专栏
