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

这是

風語·深蓝

很早以前写的一个正则表达式验证工具类，包含了一些常见的校验和支持自定义的正则表达式匹配，可以选择完全匹配，也可以获取所有匹配项。曾用它仿造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.   &