比较全的正则表达验证类C#

 

引自 風語·深蓝的 正则表达验证类，看到后觉得非常的全面，不过他的是很早就写了，特地拿来和大家分享！

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. }