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

这是

風語·深蓝

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

1. usingSystem;
2. usingSystem.Collections;
3. usingSystem.Text.RegularExpressions;
5. namespaceXrinehart.Framework.Common.Validate
6. {
7. /**////<summary>
8. ///RegularMatch的摘要说明。
9. ///</summary>
10. publicclassRegularMatch
11. {
12. privatestring_String;
13. privatebool_IsEntirety;
15. /**////<summary>
16. ///可以进行判断的类型
17. ///</summary>
18. publicenumOperation
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. publicRegularMatch(){}
27. 用于判断字符串是否是对应类型（默认为包含匹配）#region用于判断字符串是否是对应类型（默认为包含匹配）
28. publicboolIsAccordType(stringstrVerifyString,Operationop)
29. {
30. returnIsAccordType(strVerifyString,op,false);
31. }
32. #endregion
34. 用于判断字符串是否是对应类型（或是否包含对应类型的字符）#region用于判断字符串是否是对应类型（或是否包含对应类型的字符）
35. /**////<summary>
36. ///用于判断字符串是否是对应类型
37. ///</summary>
38. ///<paramname="strVerifyString">String，需要判断的字符串</param>
39. ///<paramname="op">Operation枚举，用于选择需要进行的操作</param>
40. ///<paramname="IsEntirety">Boolean，判断是完全匹配还是包含匹配模式（仅适用于非类型判断时）</param>
41. ///<returns></returns>
42. publicboolIsAccordType(stringstrVerifyString,Operationop,boolIsEntirety)
43. {
44. _String=strVerifyString;
45. _IsEntirety=IsEntirety;
47. switch(op)
48. {
49. caseOperation.Byte:
50. {
51. returnIsByte();
52. }
53. caseOperation.SByte:
54. {
55. returnIsSByte();
56. }
57. caseOperation.Int16:
58. {
59. returnIsInt16();
60. }
61. caseOperation.Int32:
62. {
63. returnIsInt32();
64. }
65. caseOperation.Int64:
66. {
67. returnIsInt64();
68. }
69. caseOperation.Single:
70. {
71. returnIsSingle();
72. }
73. caseOperation.Double:
74. {
75. returnIsDouble();
76. }
77. caseOperation.Boolean:
78. {
79. returnIsBoolean();
80. }
81. caseOperation.Char:
82. {
83. returnIsChar();
84. }
85. caseOperation.Decimal:
86. {
87. returnIsDecimal();
88. }
89. caseOperation.DateTime:
90. {
91. returnIsDateTime();
92. }
93. caseOperation.Date:
94. {
95. returnIsDate();
96. }
97. caseOperation.Time:
98. {
99. returnIsTime();
100. }
101. caseOperation.IPAddress:
102. {
103. returnIsIPAddress();
104. }
105. caseOperation.ChinaPhone:
106. {
107. returnIsChinaPhone();
108. }
109. caseOperation.ChinesePostalCode:
110. {
111. returnIsChinesePostalCode();
112. }
113. caseOperation.ChineseMobile:
114. {
115. returnIsChineseMobile();
116. }
117. caseOperation.EMail:
118. {
119. returnIsEmail();
120. }
121. caseOperation.URL:
122. {
123. returnIsURL();
124. }
125. caseOperation.ChineseWord:
126. {
127. returnIsChineseWord();
128. }
129. caseOperation.Number:
130. {
131. returnIsNumber();
132. }
133. caseOperation.StringModel_01:
134. {
135. returnIsStringModel_01();
136. }
137. caseOperation.StringModel_02:
138. {
139. returnIsStringModel_02();
140. }
141. caseOperation.WideWord:
142. {
143. returnIsWideWord();
144. }
145. caseOperation.NarrowWord:
146. {
147. returnIsNarrowWord();
148. }
149. caseOperation.ChineseID:
150. {
151. returnIsChineseID();
152. }
153. default:
154. {
155. returnfalse;
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. protectedboolIsByte()
169. {
170. try
171. {
172. Byte.Parse(_String);
173. }
174. catch
175. {
176. returnfalse;
177. }
178. returntrue;
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. protectedboolIsSByte()
188. {
189. try
190. {
191. SByte.Parse(_String);
192. }
193. catch
194. {
195. returnfalse;
196. }
197. returntrue;
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. protectedboolIsInt16()
207. {
208. try
209. {
210. Int16.Parse(_String);
211. }
212. catch
213. {
214. returnfalse;
215. }
216. returntrue;
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. protectedboolIsInt32()
226. {
227. try
228. {
229. Int32.Parse(_String);
230. }
231. catch
232. {
233. returnfalse;
234. }
235. returntrue;
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. protectedboolIsInt64()
245. {
246. try
247. {
248. Int64.Parse(_String);
249. }
250. catch
251. {
252. returnfalse;
253. }
254. returntrue;
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. protectedboolIsSingle()
264. {
265. try
266. {
267. Single.Parse(_String);
268. }
269. catch
270. {
271. returnfalse;
272. }
273. returntrue;
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. protectedboolIsDouble()
283. {
284. try
285. {
286. Double.Parse(_String);
287. }
288. catch
289. {
290. returnfalse;
291. }
292. returntrue;
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. protectedboolIsBoolean()
302. {
303. try
304. {
305. Boolean.Parse(_String);
306. }
307. catch
308. {
309. returnfalse;
310. }
311. returntrue;
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. protectedboolIsChar()
321. {
322. try
323. {
324. Char.Parse(_String);
325. }
326. catch
327. {
328. returnfalse;
329. }
330. returntrue;
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. protectedboolIsDecimal()
340. {
341. try
342. {
343. Decimal.Parse(_String);
344. }
345. catch
346. {
347. returnfalse;
348. }
349. returntrue;
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. protectedboolIsDateTime()
359. {
360. try
361. {
362. DateTime.Parse(_String);
363. }
364. catch
365. {
366. returnfalse;
367. }
368. returntrue;
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. protectedboolIsDate()
378. {
379. DateTimeValue;
380. try
381. {
382. Value=DateTime.Parse(_String);
383. }
384. catch
385. {
386. returnfalse;
387. }
388. if(Value.Date.ToString()==_String)
389. {
390. returntrue;
391. }
392. else
393. {
394. returnfalse;
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. protectedboolIsTime()
405. {
406. DateTimeValue;
407. try
408. {
409. Value=DateTime.Parse(_String);
410. }
411. catch
412. {
413. returnfalse;
414. }
415. if(Value.Year==1&&Value.Month==1&&Value.Day==1)
416. {
417. returntrue;
418. }
419. else
420. {
421. returnfalse;
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. protectedboolIsIPAddress()
432. {
433. try
434. {
435. System.Net.IPAddress.Parse(_String);
436. }
437. catch
438. {
439. returnfalse;
440. }
441. returntrue;
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. protectedboolIsChinaPhone()
451. {
452. ArrayListaryResult=newArrayList();
453. returnCommRegularMatch(_String,@"(\d{3,4})-?\d{7,8}",RegexOptions.None,refaryResult,_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. protectedboolIsChinesePostalCode()
463. {
464. ArrayListaryResult=newArrayList();
465. returnCommRegularMatch(_String,@"\d{6}",RegexOptions.None,refaryResult,_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. protectedboolIsChineseMobile()
475. {
476. ArrayListaryResult=newArrayList();
477. returnCommRegularMatch(_String,@"13\d{9}",RegexOptions.None,refaryResult,_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. protectedboolIsEmail()
487. {
488. ArrayListaryResult=newArrayList();
489. returnCommRegularMatch(_String,@"\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*",RegexOptions.None,refaryResult,_IsEntirety);
490. }
491. #endregion
493. 是否InternetURL地址类型（http://）#region是否InternetURL地址类型（http://）
494. /**////<summary>
495. ///是否InternetURL地址类型（http://）
496. ///</summary>
497. ///<returns>Boolean</returns>
498. protectedboolIsURL()
499. {
500. ArrayListaryResult=newArrayList();
501. returnCommRegularMatch(_String,@"http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?",RegexOptions.None,refaryResult,_IsEntirety);
502. }
503. #endregion
505. 是否中文字符（[\u4e00-\u9fa5]）#region是否中文字符（[\u4e00-\u9fa5]）
506. /**////<summary>
507. ///是否中文字符（[\u4e00-\u9fa5]）
508. ///</summary>
509. ///<returns>Boolean</returns>
510. protectedboolIsChineseWord()
511. {
512. ArrayListaryResult=newArrayList();
513. returnCommRegularMatch(_String,@"[\u4e00-\u9fa5]",RegexOptions.None,refaryResult,_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. protectedboolIsNumber()
523. {
524. ArrayListaryResult=newArrayList();
525. returnCommRegularMatch(_String,@"[\d]+",RegexOptions.None,refaryResult,_IsEntirety);
526. }
527. #endregion
529. 是否只包含数字，英文和下划线（[\w]+）#region是否只包含数字，英文和下划线（[\w]+）
530. /**////<summary>
531. ///是否只包含数字，英文和下划线（[\w]+）
532. ///</summary>
533. ///<returns>Boolean</returns>
534. protectedboolIsStringModel_01()
535. {
536. ArrayListaryResult=newArrayList();
537. returnCommRegularMatch(_String,@"[\w]+",RegexOptions.None,refaryResult,_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. protectedboolIsStringModel_02()
547. {
548. ArrayListaryResult=newArrayList();
549. returnCommRegularMatch(_String,@"[A-Z][a-z]+",RegexOptions.None,refaryResult,_IsEntirety);
550. }
551. #endregion
553. 是否全角字符（[^\x00-\xff]）：包括汉字在内#region是否全角字符（[^\x00-\xff]）：包括汉字在内
554. /**////<summary>
555. ///是否全角字符（[^\x00-\xff]）：包括汉字在内
556. ///</summary>
557. ///<returns>Boolean</returns>
558. protectedboolIsWideWord()
559. {
560. ArrayListaryResult=newArrayList();
561. returnCommRegularMatch(_String,@"[^\x00-\xff]",RegexOptions.None,refaryResult,_IsEntirety);
562. }
563. #endregion
565. 是否半角字符（[\x00-\xff]）#region是否半角字符（[\x00-\xff]）
566. /**////<summary>
567. ///是否半角字符（[^\x00-\xff]）：包括汉字在内
568. ///</summary>
569. ///<returns>Boolean</returns>
570. protectedboolIsNarrowWord()
571. {
572. ArrayListaryResult=newArrayList();
573. returnCommRegularMatch(_String,@"[\x00-\xff]",RegexOptions.None,refaryResult,_IsEntirety);
574. }
575. #endregion
577. 是否合法的中国身份证号码#region是否合法的中国身份证号码
578. protectedboolIsChineseID()
579. {
580. if(_String.Length==15)
581. {
582. _String=CidUpdate(_String);
583. }
584. if(_String.Length==18)
585. {
586. stringstrResult=CheckCidInfo(_String);
587. if(strResult=="非法地区"||strResult=="非法生日"||strResult=="非法证号")
588. {
589. returnfalse;
590. }
591. else
592. {
593. returntrue;
594. }
595. }
596. else
597. {
598. returnfalse;
599. }
600. }
601. #endregion
603. #endregion
605. 通用正则表达式判断函数#region通用正则表达式判断函数
606. /**////<summary>
607. ///通用正则表达式判断函数
608. ///</summary>
609. ///<paramname="strVerifyString">String，用于匹配的字符串</param>
610. ///<paramname="strRegular">String，正则表达式</param>
611. ///<paramname="regOption">RegexOptions，配置正则表达式的选项</param>
612. ///<paramname="aryResult">ArrayList，分解的字符串内容</param>
613. ///<paramname="IsEntirety">Boolean，是否需要完全匹配</param>
614. ///<returns></returns>
615. publicboolCommRegularMatch(stringstrVerifyString,stringstrRegular,System.Text.RegularExpressions.RegexOptionsregOption,refSystem.Collections.ArrayListaryResult,boolIsEntirety)
616. {
617. System.Text.RegularExpressions.Regexr;
618. System.Text.RegularExpressions.Matchm;
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=newSystem.Text.RegularExpressions.Regex(strRegular,regOption);
631. }
632. catch(System.Exceptione)
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. returnfalse;
645. }
646. else
647. {
648. returntrue;
649. }
650. }
651. #endregion
653. 中国身份证号码验证#region中国身份证号码验证
654. privatestringCheckCidInfo(stringcid)
655. {
656. string[]aCity=newstring[]{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. doubleiSum=0;
658. stringinfo=string.Empty;
659. System.Text.RegularExpressions.Regexrg=newSystem.Text.RegularExpressions.Regex(@"^\d{17}(\d|x)$");
660. System.Text.RegularExpressions.Matchmc=rg.Match(cid);
661. if(!mc.Success)
662. {
663. returnstring.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(inti=17;i>=0;i--)
680. {
681. iSum+=(System.Math.Pow(2,i)%11)*int