网站首页  汉语字词  英语词汇  考试资料  写作素材  旧版资料

请输入您要查询的考试资料：

　

标题 一个常用的正则表达验证类
内容
    很早以前写的一个正则表达式验证工具类，包含了一些常见的校验和支持自定义的正则表达式匹配，可以选择完全匹配，也可以获取所有匹配项。曾用它仿造Eclispe下的正则表达式插件写过一个工具。因为最近突然有几个朋友都在问这方面的问题，干脆就把代码贴出来好了。
    using System;
    02.using System.Collections;
    03.using System.Text.RegularExpressions;
    04.
    05.namespace Xrinehart.Framework.Common.Validate
    06.{
    07. /**//// <summary>
    08. /// RegularMatch 的摘要说明。
    09. /// </summary>
    10. public class RegularMatch
    11. {
    12. private string _String;
    13. private bool _IsEntirety;
    14.
    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. };
    24.
    25. public RegularMatch() { }
    26.
    27. 用于判断字符串是否是对应类型（默认为包含匹配）#region 用于判断字符串是否是对应类型（默认为包含匹配）
    28. public bool IsAccordType(string strVerifyString, Operation op)
    29. {
    30. return IsAccordType(strVerifyString, op, false);
    31. }
    32. #endregion
    33.
    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;
    46.
    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
    160.
    161. 具体验证方法#region 具体验证方法
    162.
    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
    181.
    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
    200.
    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
    219.
    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
    238.
    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
    257.
    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
    276.
    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
    295.
    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
    314.
    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
    333.
    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
    352.
    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
    371.
    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
    398.
    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
    425.
    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
    444.
    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
    456.
    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
    468.
    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
    480.
    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
    492.
    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
    504.
    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
    516.
    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
    528.
    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
    540.
    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
    552.
    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
    564.
    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
    576.
    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
    602.
    603. #endregion
    604.
    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;
    619.
    620. 如果需要完全匹配的处理#region 如果需要完全匹配的处理
    621. if (IsEntirety)
    622. {
    623. strRegular = strRegular.Insert(0, @"/A");
    624. strRegular = strRegular.Insert(strRegular.Length, @"/z");
    625. }
    626. #endregion
    627.
    628. try
    629. {
    630. r = new System.Text.RegularExpressions.Regex(strRegular, regOption);
    631. }
    632. catch (System.Exception e)
    633. {
    634. throw (e);
    635. }
    636.
    637. for (m = r.Match(strVerifyString); m.Success; m = m.NextMatch())
    638. {
    639. aryResult.Add(m);
    640. }
    641.
    642. if (aryResult.Count == 0)
    643. {
    644. return false;
    645. }
    646. else
    647. {
    648. return true;
    649. }
    650. }
    651. #endregion
    652.
    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
    693.
    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;
    701.
    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.}
随便看

　

在线学习网考试资料包含高考、自考、专升本考试、人事考试、公务员考试、大学生村官考试、特岗教师招聘考试、事业单位招聘考试、企业人才招聘、银行招聘、教师招聘、农村信用社招聘、各类资格证书考试等各类考试资料。

　

Copyright © 2002-2024 cuapp.net All Rights Reserved
更新时间：2025/5/15 17:50:59