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

这是

風語·深蓝

很早以前写的一个正则表达式验证工具类,包含了一些常见的校验和支持自定义的正则表达式匹配,可以选择完全匹配,也可以获取所有匹配项。曾用它仿造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[] { nullnullnullnullnullnullnullnullnullnullnull"北京""天津""河北""山西""内蒙古"nullnullnullnullnull"辽宁""吉林""黑龙江"nullnullnullnullnullnullnull"上海""江苏""浙江""安微""福建""江西""山东"nullnullnull"河南""湖北""湖南""广东""广西""海南"nullnullnull"重庆""四川""贵州""云南""西藏"nullnullnullnullnullnull"陕西""甘肃""青海""宁夏""新疆"nullnullnullnullnull"台湾"nullnullnullnullnullnullnullnullnull"香港""澳门"nullnullnullnullnullnullnullnull"国外" };
  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. }
展开阅读全文

没有更多推荐了,返回首页