这是

風語·深蓝

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

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

一个常用的正则表达验证类相关推荐

  1. php 密码校验正则,PHP常用密码正则匹配验证

    PHP常用密码正则匹配验证 第一种: //昵称2-10位字符,需由中文.数字.字母(区分大小写)和下划线组合 $a = '的方'; $b = preg_match( "/^[\x{4e00} ...

  2. 正则表达+验证 [记录]

    时间 日期 日期时间//日期 2014-01-01var reg = /^[1-9]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])$/;//时间 12 ...

  3. 常用的正则表达式验证类

    搜集的一些常用的正则表达式验证类: using System;  using System.Text.RegularExpressions;    namespace CommonTools  {  ...

  4. 企业信用代码等常用的正则验证

    常用的正则验证方法整合 使用 var Reg = (/\S/g)==null // 判断是否为空 var nameReg = /^[\u4E00-\u9FA5]{2,4}$/; // 名字 var i ...

  5. layui 验证小数点唯一正则表达

    layui 验证小数点唯一正则表达 我在网上找了一大圈 表单验证小数点唯一正确性 <div class="col-sm-10"><input type=" ...

  6. 简单高效有用的正则表达

    简单高效有用的正则表达 正则表达式是一组由字母和符号组成的特殊文本,它可以用来从文本中找出满足你想要的格式的句子.本集讲解正则表达式. 0. 举例 一个正则表达式是一种从左到右匹配主体字符串的模式.& ...

  7. 经典 正则表达技术文档

    正则表达式语法 一个正则表达式就是由普通字符(例如字符 a 到 z)以及特殊字符(称为元字符)组成的文字模式.该模式描 述在查找文字主体时待匹配的一个或多个字符串.正则表达式作为一个模板,将某个字符模 ...

  8. Python 之正则表达re.compile()与re.findall()详解

    在使用爬虫提取网页中的部分信息时,采用到了re.compile()与re.findall()两种方法,目的:把网页中的"某某城市土地规划表"截取并打印出来. 网页中的代码: < ...

  9. 前端常用的 59 个工具类【持续更新】

    #前端常用的 59 个工具类[持续更新] 前言 前端开发有时会处理一部分后台返回的数据,或者根据数据判断做一些处理; 这个时候就非常有必要将一些常用的工具类封装起来; 本文根据常用的一些工具类封装了 ...

最新文章

  1. Windows Azure Service Bus (5) 主题(Topic) 使用VS2013开发Service Bus Topic
  2. 常用HTTP状态码趣(曲)解
  3. Python编程基础：第五十七节 reduce函数Reduce
  4. RabbitMQ消息队列（二）：”Hello, World“
  5. MySQL的insert ignore与replace into不同
  6. mysql在linux下的安装(5.7版本以后)
  7. 重学ASP.NET Core 中的标记帮助程序
  8. Leetcode 28. 实现 strStr()
  9. java使用的页面静态化技术_java秒杀系列（2）- 页面静态化技术
  10. 雷锋实验室：Evernote的中国门徒
  11. php对联广告代码,网站漂浮对联广告代码
  12. AJRW错误AA707
  13. Leetcode-714. 买卖股票的最佳时机含手续费
  14. 通过Matlab实现函数的简单的微分积分运算
  15. 蓝桥杯：第39级台阶
  16. 在命令行下转换磁盘分区格式为GPT或MBR（会丢失所有数据）
  17. php获取蓝凑云文件列表,自制蓝奏云网盘解析接口全解
  18. 关于echarts图例lengend自定义
  19. [人工智能]得人工智能者得天下？百度200万美元奖励不到20人的团队
  20. 复工复产，利用Python爬虫爬取火车票信息

热门文章

  1. mysql 二进制日志变化_mysql-二进制日志
  2. Linux下进程间通信-------管道通信
  3. LaneATT调试笔记
  4. 【opencv】(7) 图像匹配、直方图、图像均衡化
  5. C语言中连续调用rand函数,返回值不变
  6. python代码变量作业_python - 是否可以在Jenkins的代码中注入变量，然后像往常一样运行作业？ - SO中文参考 - www.soinside.com...
  7. python绝对路径的区别_python学习：绝对路径和相对路径
  8. bmp文件头_「正点原子FPGA连载」第十九章SD卡读BMP图片LCD显示
  9. CUDA make_float3和make_float4
  10. 转换数字为像素px单位