一个常用的正则表达验证类

这是

風語·深蓝

很早以前写的一个正则表达式验证工具类，包含了一些常见的校验和支持自定义的正则表达式匹配，可以选择完全匹配，也可以获取所有匹配项。曾用它仿造Eclispe下的正则表达式插件写过一个工具。因为最近突然有几个朋友都在问这方面的问题，干脆就把代码贴出来好了。

1. using System;
2. using System.Collections;
3. using System.Text.RegularExpressions;
5. namespace Xrinehart.Framework.Common.Validate
6. {
7.     /**//// <summary>
8.     /// RegularMatch 的摘要说明。
9.     /// </summary>    
10.     public class RegularMatch
11.     {
12.         private string _String;
13.         private bool _IsEntirety;
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.         };
25.         public RegularMatch() { }
27.         用于判断字符串是否是对应类型（默认为包含匹配）#region 用于判断字符串是否是对应类型（默认为包含匹配）
28.         public bool IsAccordType(string strVerifyString, Operation op)
29.         {
30.             return IsAccordType(strVerifyString, op, false);
31.         }
32.         #endregion
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;
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
161.         具体验证方法#region 具体验证方法
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
603.         #endregion
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;
620.             如果需要完全匹配的处理#region 如果需要完全匹配的处理
621.             if (IsEntirety)
622.             {
623.                 strRegular = strRegular.Insert(0, @"\A");
624.                 strRegular = strRegular.Insert(strRegular.Length, @"\z");
625.             }
626.             #endregion
628.             try
629.             {
630.                 r = new System.Text.RegularExpressions.Regex(strRegular, regOption);
631.             }
632.             catch (System.Exception e)
633.             {
634.                 throw (e);
635.             }
637.             for (m = r.Match(strVerifyString); m.Success; m = m.NextMatch())
638.             {
639.                 aryResult.Add(m);
640.             }
642.             if (aryResult.Count == 0)
643.             {
644.                 return false;
645.             }
646.             else
647.             {
648.                 return true;
649.             }
650.         }
651.         #endregion
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
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;
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. }