C# 正则实例

C# 正则实例
[csharp] view plain copy
 
  1. using System;  
  2. using System.Collections.Generic;  
  3. using System.Linq;  
  4. using System.Text;  
  5.   
  6. using System.Text.RegularExpressions;//引用验证的命名空间  
  7.   
  8. namespace XClassLibrary  
  9. {  
  10.     public class Validator  
  11.     {  
  12.         #region 匹配方法  
  13.         /// <summary>  
  14.         /// 验证字符串是否匹配正则表达式描述的规则  
  15.         /// </summary>  
  16.         /// <param name="inputStr">待验证的字符串</param>  
  17.         /// <param name="patternStr">正则表达式字符串</param>  
  18.         /// <returns>是否匹配</returns>  
  19.         public static bool IsMatch(string inputStr, string patternStr)  
  20.         {  
  21.             return IsMatch(inputStr, patternStr, false, false);  
  22.         }  
  23.   
  24.         /// <summary>  
  25.         /// 验证字符串是否匹配正则表达式描述的规则  
  26.         /// </summary>  
  27.         /// <param name="inputStr">待验证的字符串</param>  
  28.         /// <param name="patternStr">正则表达式字符串</param>  
  29.         /// <param name="ifIgnoreCase">匹配时是否不区分大小写</param>  
  30.         /// <returns>是否匹配</returns>  
  31.         public static bool IsMatch(string inputStr, string patternStr, bool ifIgnoreCase)  
  32.         {  
  33.             return IsMatch(inputStr, patternStr, ifIgnoreCase, false);  
  34.         }  
  35.   
  36.         /// <summary>  
  37.         /// 验证字符串是否匹配正则表达式描述的规则  
  38.         /// </summary>  
  39.         /// <param name="inputStr">待验证的字符串</param>  
  40.         /// <param name="patternStr">正则表达式字符串</param>  
  41.         /// <param name="ifValidateWhiteSpace">是否验证空白字符串</param>  
  42.         /// <returns>是否匹配</returns>  
  43.         public static bool IsMatch(string inputStr, string patternStr, bool ifValidateWhiteSpace)  
  44.         {  
  45.             return IsMatch(inputStr, patternStr, false, ifValidateWhiteSpace);  
  46.         }  
  47.   
  48.         /// <summary>  
  49.         /// 验证字符串是否匹配正则表达式描述的规则  
  50.         /// </summary>  
  51.         /// <param name="inputStr">待验证的字符串</param>  
  52.         /// <param name="patternStr">正则表达式字符串</param>  
  53.         /// <param name="ifIgnoreCase">匹配时是否不区分大小写</param>  
  54.         /// <param name="ifValidateWhiteSpace">是否验证空白字符串</param>  
  55.         /// <returns>是否匹配</returns>  
  56.         public static bool IsMatch(string inputStr, string patternStr, bool ifIgnoreCase, bool ifValidateWhiteSpace)  
  57.         {  
  58.             if (!ifValidateWhiteSpace && string.IsNullOrWhiteSpace(inputStr))  
  59.                 return false;//如果不要求验证空白字符串而此时传入的待验证字符串为空白字符串，则不匹配  
  60.             Regex regex = null;  
  61.             if (ifIgnoreCase)  
  62.                 regex = new Regex(patternStr, RegexOptions.IgnoreCase);//指定不区分大小写的匹配  
  63.             else  
  64.                 regex = new Regex(patternStr);  
  65.             return regex.IsMatch(inputStr);  
  66.         }  
  67.         #endregion  
  68.  
  69.         #region 验证方法  
  70.         /// <summary>  
  71.         /// 验证数字(double类型)  
  72.         /// [可以包含负号和小数点]  
  73.         /// </summary>  
  74.         /// <param name="input">待验证的字符串</param>  
  75.         /// <returns>是否匹配</returns>  
  76.         public static bool IsNumber(string input)  
  77.         {  
  78.             //string pattern = @"^-?\d+$|^(-?\d+)(\.\d+)?$";  
  79.             //return IsMatch(input, pattern);  
  80.             double d = 0;  
  81.             if (double.TryParse(input, out d))  
  82.                 return true;  
  83.             else  
  84.                 return false;  
  85.         }  
  86.   
  87.         /// <summary>  
  88.         /// 验证整数  
  89.         /// </summary>  
  90.         /// <param name="input">待验证的字符串</param>  
  91.         /// <returns>是否匹配</returns>  
  92.         public static bool IsInteger(string input)  
  93.         {  
  94.             //string pattern = @"^-?\d+$";  
  95.             //return IsMatch(input, pattern);  
  96.             int i = 0;  
  97.             if (int.TryParse(input, out i))  
  98.                 return true;  
  99.             else  
  100.                 return false;  
  101.         }  
  102.   
  103.         /// <summary>  
  104.         /// 验证非负整数  
  105.         /// </summary>  
  106.         /// <param name="input">待验证的字符串</param>  
  107.         /// <returns>是否匹配</returns>  
  108.         public static bool IsIntegerNotNagtive(string input)  
  109.         {  
  110.             //string pattern = @"^\d+$";  
  111.             //return IsMatch(input, pattern);  
  112.             int i = -1;  
  113.             if (int.TryParse(input, out i) && i >= 0)  
  114.                 return true;  
  115.             else  
  116.                 return false;  
  117.         }  
  118.   
  119.         /// <summary>  
  120.         /// 验证正整数  
  121.         /// </summary>  
  122.         /// <param name="input">待验证的字符串</param>  
  123.         /// <returns>是否匹配</returns>  
  124.         public static bool IsIntegerPositive(string input)  
  125.         {  
  126.             //string pattern = @"^[0-9]*[1-9][0-9]*$";  
  127.             //return IsMatch(input, pattern);  
  128.             int i = 0;  
  129.             if (int.TryParse(input, out i) && i >= 1)  
  130.                 return true;  
  131.             else  
  132.                 return false;  
  133.         }  
  134.   
  135.         /// <summary>  
  136.         /// 验证小数  
  137.         /// </summary>  
  138.         /// <param name="input">待验证的字符串</param>  
  139.         /// <returns>是否匹配</returns>  
  140.         public static bool IsDecimal(string input)  
  141.         {  
  142.             string pattern = @"^([-+]?[1-9]\d*\.\d+|-?0\.\d*[1-9]\d*)$";  
  143.             return IsMatch(input, pattern);  
  144.         }  
  145.   
  146.         /// <summary>  
  147.         /// 验证只包含英文字母  
  148.         /// </summary>  
  149.         /// <param name="input">待验证的字符串</param>  
  150.         /// <returns>是否匹配</returns>  
  151.         public static bool IsEnglishCharacter(string input)  
  152.         {  
  153.             string pattern = @"^[A-Za-z]+$";  
  154.             return IsMatch(input, pattern);  
  155.         }  
  156.   
  157.         /// <summary>  
  158.         /// 验证只包含数字和英文字母  
  159.         /// </summary>  
  160.         /// <param name="input">待验证的字符串</param>  
  161.         /// <returns>是否匹配</returns>  
  162.         public static bool IsIntegerAndEnglishCharacter(string input)  
  163.         {  
  164.             string pattern = @"^[0-9A-Za-z]+$";  
  165.             return IsMatch(input, pattern);  
  166.         }  
  167.   
  168.         /// <summary>  
  169.         /// 验证只包含汉字  
  170.         /// </summary>  
  171.         /// <param name="input">待验证的字符串</param>  
  172.         /// <returns>是否匹配</returns>  
  173.         public static bool IsChineseCharacter(string input)  
  174.         {  
  175.             string pattern = @"^[\u4e00-\u9fa5]+$";  
  176.             return IsMatch(input, pattern);  
  177.         }  
  178.   
  179.         /// <summary>  
  180.         /// 验证数字长度范围（数字前端的0计长度）  
  181.         /// [若要验证固定长度，可传入相同的两个长度数值]  
  182.         /// </summary>  
  183.         /// <param name="input">待验证的字符串</param>  
  184.         /// <param name="lengthBegin">长度范围起始值（含）</param>  
  185.         /// <param name="lengthEnd">长度范围结束值（含）</param>  
  186.         /// <returns>是否匹配</returns>  
  187.         public static bool IsIntegerLength(string input, int lengthBegin, int lengthEnd)  
  188.         {  
  189.             //string pattern = @"^\d{" + lengthBegin + "," + lengthEnd + "}$";  
  190.             //return IsMatch(input, pattern);  
  191.             if (input.Length >= lengthBegin && input.Length <= lengthEnd)  
  192.             {  
  193.                 int i;  
  194.                 if (int.TryParse(input, out i))  
  195.                     return true;  
  196.                 else  
  197.                     return false;  
  198.             }  
  199.             else  
  200.                 return false;  
  201.         }  
  202.   
  203.         /// <summary>  
  204.         /// 验证字符串包含内容  
  205.         /// </summary>  
  206.         /// <param name="input">待验证的字符串</param>  
  207.         /// <param name="withEnglishCharacter">是否包含英文字母</param>  
  208.         /// <param name="withNumber">是否包含数字</param>  
  209.         /// <param name="withChineseCharacter">是否包含汉字</param>  
  210.         /// <returns>是否匹配</returns>  
  211.         public static bool IsStringInclude(string input, bool withEnglishCharacter, bool withNumber, bool withChineseCharacter)  
  212.         {  
  213.             if (!withEnglishCharacter && !withNumber && !withChineseCharacter)  
  214.                 return false;//如果英文字母、数字和汉字都没有，则返回false  
  215.             StringBuilder patternString = new StringBuilder();  
  216.             patternString.Append("^[");  
  217.             if (withEnglishCharacter)  
  218.                 patternString.Append("a-zA-Z");  
  219.             if (withNumber)  
  220.                 patternString.Append("0-9");  
  221.             if (withChineseCharacter)  
  222.                 patternString.Append(@"\u4E00-\u9FA5");  
  223.             patternString.Append("]+$");  
  224.             return IsMatch(input, patternString.ToString());  
  225.         }  
  226.   
  227.         /// <summary>  
  228.         /// 验证字符串长度范围  
  229.         /// [若要验证固定长度，可传入相同的两个长度数值]  
  230.         /// </summary>  
  231.         /// <param name="input">待验证的字符串</param>  
  232.         /// <param name="lengthBegin">长度范围起始值（含）</param>  
  233.         /// <param name="lengthEnd">长度范围结束值（含）</param>  
  234.         /// <returns>是否匹配</returns>  
  235.         public static bool IsStringLength(string input, int lengthBegin, int lengthEnd)  
  236.         {  
  237.             //string pattern = @"^.{" + lengthBegin + "," + lengthEnd + "}$";  
  238.             //return IsMatch(input, pattern);  
  239.             if (input.Length >= lengthBegin && input.Length <= lengthEnd)  
  240.                 return true;  
  241.             else  
  242.                 return false;  
  243.         }  
  244.   
  245.         /// <summary>  
  246.         /// 验证字符串长度范围（字符串内只包含数字和/或英文字母）  
  247.         /// [若要验证固定长度，可传入相同的两个长度数值]  
  248.         /// </summary>  
  249.         /// <param name="input">待验证的字符串</param>  
  250.         /// <param name="lengthBegin">长度范围起始值（含）</param>  
  251.         /// <param name="lengthEnd">长度范围结束值（含）</param>  
  252.         /// <returns>是否匹配</returns>  
  253.         public static bool IsStringLengthOnlyNumberAndEnglishCharacter(string input, int lengthBegin, int lengthEnd)  
  254.         {  
  255.             string pattern = @"^[0-9a-zA-z]{" + lengthBegin + "," + lengthEnd + "}$";  
  256.             return IsMatch(input, pattern);  
  257.         }  
  258.   
  259.         /// <summary>  
  260.         /// 验证字符串长度范围  
  261.         /// [若要验证固定长度，可传入相同的两个长度数值]  
  262.         /// </summary>  
  263.         /// <param name="input">待验证的字符串</param>  
  264.         /// <param name="withEnglishCharacter">是否包含英文字母</param>  
  265.         /// <param name="withNumber">是否包含数字</param>  
  266.         /// <param name="withChineseCharacter">是否包含汉字</param>  
  267.         /// <param name="lengthBegin">长度范围起始值（含）</param>  
  268.         /// <param name="lengthEnd">长度范围结束值（含）</param>  
  269.         /// <returns>是否匹配</returns>  
  270.         public static bool IsStringLengthByInclude(string input, bool withEnglishCharacter, bool withNumber, bool withChineseCharacter, int lengthBegin, int lengthEnd)  
  271.         {  
  272.             if (!withEnglishCharacter && !withNumber && !withChineseCharacter)  
  273.                 return false;//如果英文字母、数字和汉字都没有，则返回false  
  274.             StringBuilder patternString = new StringBuilder();  
  275.             patternString.Append("^[");  
  276.             if (withEnglishCharacter)  
  277.                 patternString.Append("a-zA-Z");  
  278.             if (withNumber)  
  279.                 patternString.Append("0-9");  
  280.             if (withChineseCharacter)  
  281.                 patternString.Append(@"\u4E00-\u9FA5");  
  282.             patternString.Append("]{" + lengthBegin + "," + lengthEnd + "}$");  
  283.             return IsMatch(input, patternString.ToString());  
  284.         }  
  285.   
  286.         /// <summary>  
  287.         /// 验证字符串字节数长度范围  
  288.         /// [若要验证固定长度，可传入相同的两个长度数值；每个汉字为两个字节长度]  
  289.         /// </summary>  
  290.         /// <param name="input">待验证的字符串</param>  
  291.         /// <param name="lengthBegin">长度范围起始值（含）</param>  
  292.         /// <param name="lengthEnd">长度范围结束值（含）</param>  
  293.         /// <returns></returns>  
  294.         public static bool IsStringByteLength(string input, int lengthBegin, int lengthEnd)  
  295.         {  
  296.             //int byteLength = Regex.Replace(input, @"[^\x00-\xff]", "ok").Length;  
  297.             //if (byteLength >= lengthBegin && byteLength <= lengthEnd)  
  298.             //{  
  299.             //    return true;  
  300.             //}  
  301.             //return false;  
  302.             int byteLength = Encoding.Default.GetByteCount(input);  
  303.             if (byteLength >= lengthBegin && byteLength <= lengthEnd)  
  304.                 return true;  
  305.             else  
  306.                 return false;  
  307.         }  
  308.   
  309.         /// <summary>  
  310.         /// 验证日期  
  311.         /// </summary>  
  312.         /// <param name="input">待验证的字符串</param>  
  313.         /// <returns>是否匹配</returns>  
  314.         public static bool IsDateTime(string input)  
  315.         {  
  316.             DateTime dt;  
  317.             if (DateTime.TryParse(input, out dt))  
  318.                 return true;  
  319.             else  
  320.                 return false;  
  321.         }  
  322.   
  323.         /// <summary>  
  324.         /// 验证固定电话号码  
  325.         /// [3位或4位区号；区号可以用小括号括起来；区号可以省略；区号与本地号间可以用减号或空格隔开；可以有3位数的分机号，分机号前要加减号]  
  326.         /// </summary>  
  327.         /// <param name="input">待验证的字符串</param>  
  328.         /// <returns>是否匹配</returns>  
  329.         public static bool IsTelePhoneNumber(string input)  
  330.         {  
  331.             string pattern = @"^(((0\d2|0\d{2})[- ]?)?\d{8}|((0\d3|0\d{3})[- ]?)?\d{7})(-\d{3})?$";  
  332.             return IsMatch(input, pattern);  
  333.         }  
  334.   
  335.         /// <summary>  
  336.         /// 验证手机号码  
  337.         /// [可匹配"(+86)013325656352"，括号可以省略，+号可以省略，(+86)可以省略，11位手机号前的0可以省略；11位手机号第二位数可以是3、4、5、8中的任意一个]  
  338.         /// </summary>  
  339.         /// <param name="input">待验证的字符串</param>  
  340.         /// <returns>是否匹配</returns>  
  341.         public static bool IsMobilePhoneNumber(string input)  
  342.         {  
  343.             string pattern = @"^((\+)?86|((\+)?86)?)0?1[3458]\d{9}$";  
  344.             return IsMatch(input, pattern);  
  345.         }  
  346.   
  347.         /// <summary>  
  348.         /// 验证电话号码（可以是固定电话号码或手机号码）  
  349.         /// [固定电话：[3位或4位区号；区号可以用小括号括起来；区号可以省略；区号与本地号间可以用减号或空格隔开；可以有3位数的分机号，分机号前要加减号]]  
  350.         /// [手机号码：[可匹配"(+86)013325656352"，括号可以省略，+号可以省略，(+86)可以省略，手机号前的0可以省略；手机号第二位数可以是3、4、5、8中的任意一个]]  
  351.         /// </summary>  
  352.         /// <param name="input">待验证的字符串</param>  
  353.         /// <returns>是否匹配</returns>  
  354.         public static bool IsPhoneNumber(string input)  
  355.         {  
  356.             string pattern = @"^((\+)?86|((\+)?86)?)0?1[3458]\d{9}$|^(((0\d2|0\d{2})[- ]?)?\d{8}|((0\d3|0\d{3})[- ]?)?\d{7})(-\d{3})?$";  
  357.             return IsMatch(input, pattern);  
  358.         }  
  359.   
  360.         /// <summary>  
  361.         /// 验证邮政编码  
  362.         /// </summary>  
  363.         /// <param name="input">待验证的字符串</param>  
  364.         /// <returns>是否匹配</returns>  
  365.         public static bool IsZipCode(string input)  
  366.         {  
  367.             //string pattern = @"^\d{6}$";  
  368.             //return IsMatch(input, pattern);  
  369.             if (input.Length != 6)  
  370.                 return false;  
  371.             int i;  
  372.             if (int.TryParse(input, out i))  
  373.                 return true;  
  374.             else  
  375.                 return false;  
  376.         }  
  377.   
  378.         /// <summary>  
  379.         /// 验证电子邮箱  
  380.         /// [@字符前可以包含字母、数字、下划线和点号；@字符后可以包含字母、数字、下划线和点号；@字符后至少包含一个点号且点号不能是最后一个字符；最后一个点号后只能是字母或数字]  
  381.         /// </summary>  
  382.         /// <param name="input">待验证的字符串</param>  
  383.         /// <returns>是否匹配</returns>  
  384.         public static bool IsEmail(string input)  
  385.         {  
  386.             ////邮箱名以数字或字母开头；邮箱名可由字母、数字、点号、减号、下划线组成；邮箱名（@前的字符）长度为3～18个字符；邮箱名不能以点号、减号或下划线结尾；不能出现连续两个或两个以上的点号、减号。  
  387.             //string pattern = @"^[a-zA-Z0-9]((?<!(\.\.|--))[a-zA-Z0-9\._-]){1,16}[a-zA-Z0-9]@([0-9a-zA-Z][0-9a-zA-Z-]{0,62}\.)+([0-9a-zA-Z][0-9a-zA-Z-]{0,62})\.?|((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$";  
  388.             string pattern = @"^([\w-\.]+)@([\w-\.]+)(\.[a-zA-Z0-9]+)$";  
  389.             return IsMatch(input, pattern);  
  390.         }  
  391.   
  392.         /// <summary>  
  393.         /// 验证网址（可以匹配IPv4地址但没对IPv4地址进行格式验证；IPv6暂时没做匹配）  
  394.         /// [允许省略"://"；可以添加端口号；允许层级；允许传参；域名中至少一个点号且此点号前要有内容]  
  395.         /// </summary>  
  396.         /// <param name="input">待验证的字符串</param>  
  397.         /// <returns>是否匹配</returns>  
  398.         public static bool IsURL(string input)  
  399.         {  
  400.             ////每级域名由字母、数字和减号构成（第一个字母不能是减号），不区分大小写，单个域长度不超过63，完整的域名全长不超过256个字符。在DNS系统中，全名是以一个点“.”来结束的，例如“www.nit.edu.cn.”。没有最后的那个点则表示一个相对地址。   
  401.             ////没有例如"http://"的前缀，没有传参的匹配  
  402.             //string pattern = @"^([0-9a-zA-Z][0-9a-zA-Z-]{0,62}\.)+([0-9a-zA-Z][0-9a-zA-Z-]{0,62})\.?$";  
  403.   
  404.             //string pattern = @"^(((file|gopher|news|nntp|telnet|http|ftp|https|ftps|sftp)://)|(www\.))+(([a-zA-Z0-9\._-]+\.[a-zA-Z]{2,6})|([0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}))(/[a-zA-Z0-9\&%_\./-~-]*)?$";  
  405.             string pattern = @"^([a-zA-Z]+://)?([\w-\.]+)(\.[a-zA-Z0-9]+)(:\d{0,5})?/?([\w-/]*)\.?([a-zA-Z]*)\??(([\w-]*=[\w%]*&?)*)$";  
  406.             return IsMatch(input, pattern);  
  407.         }  
  408.   
  409.         /// <summary>  
  410.         /// 验证IPv4地址  
  411.         /// [第一位和最后一位数字不能是0或255；允许用0补位]  
  412.         /// </summary>  
  413.         /// <param name="input">待验证的字符串</param>  
  414.         /// <returns>是否匹配</returns>  
  415.         public static bool IsIPv4(string input)  
  416.         {  
  417.             //string pattern = @"^(25[0-4]|2[0-4]\d]|[01]?\d{2}|[1-9])\.(25[0-5]|2[0-4]\d]|[01]?\d?\d)\.(25[0-5]|2[0-4]\d]|[01]?\d?\d)\.(25[0-4]|2[0-4]\d]|[01]?\d{2}|[1-9])$";  
  418.             //return IsMatch(input, pattern);  
  419.             string[] IPs = input.Split('.');  
  420.             if (IPs.Length != 4)  
  421.                 return false;  
  422.             int n = -1;  
  423.             for (int i = 0; i < IPs.Length; i++)  
  424.             {  
  425.                 if (i == 0 || i == 3)  
  426.                 {  
  427.                     if (int.TryParse(IPs[i], out n) && n > 0 && n < 255)  
  428.                         continue;  
  429.                     else  
  430.                         return false;  
  431.                 }  
  432.                 else  
  433.                 {  
  434.                     if (int.TryParse(IPs[i], out n) && n >= 0 && n <= 255)  
  435.                         continue;  
  436.                     else  
  437.                         return false;  
  438.                 }  
  439.             }  
  440.             return true;  
  441.         }  
  442.   
  443.         /// <summary>  
  444.         /// 验证IPv6地址  
  445.         /// [可用于匹配任何一个合法的IPv6地址]  
  446.         /// </summary>  
  447.         /// <param name="input">待验证的字符串</param>  
  448.         /// <returns>是否匹配</returns>  
  449.         public static bool IsIPv6(string input)  
  450.         {  
  451.             string pattern = @"^\s*((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\s*$";  
  452.             return IsMatch(input, pattern);  
  453.         }  
  454.   
  455.         /// <summary>  
  456.         /// 身份证上数字对应的地址  
  457.         /// </summary>  
  458.         //enum IDAddress  
  459.         //{  
  460.         //    北京 = 11, 天津 = 12, 河北 = 13, 山西 = 14, 内蒙古 = 15, 辽宁 = 21, 吉林 = 22, 黑龙江 = 23, 上海 = 31, 江苏 = 32, 浙江 = 33,  
  461.         //    安徽 = 34, 福建 = 35, 江西 = 36, 山东 = 37, 河南 = 41, 湖北 = 42, 湖南 = 43, 广东 = 44, 广西 = 45, 海南 = 46, 重庆 = 50, 四川 = 51,  
  462.         //    贵州 = 52, 云南 = 53, 西藏 = 54, 陕西 = 61, 甘肃 = 62, 青海 = 63, 宁夏 = 64, 新疆 = 65, 台湾 = 71, 香港 = 81, 澳门 = 82, 国外 = 91  
  463.         //}  
  464.   
  465.         /// <summary>  
  466.         /// 验证一代身份证号（15位数）  
  467.         /// [长度为15位的数字；匹配对应省份地址；生日能正确匹配]  
  468.         /// </summary>  
  469.         /// <param name="input">待验证的字符串</param>  
  470.         /// <returns>是否匹配</returns>  
  471.         public static bool IsIDCard15(string input)  
  472.         {  
  473.             //验证是否可以转换为15位整数  
  474.             long l = 0;  
  475.             if (!long.TryParse(input, out l) || l.ToString().Length != 15)  
  476.             {  
  477.                 return false;  
  478.             }  
  479.             //验证省份是否匹配  
  480.             //1~6位为地区代码，其中1、2位数为各省级政府的代码，3、4位数为地、市级政府的代码，5、6位数为县、区级政府代码。  
  481.             string address = "11,12,13,14,15,21,22,23,31,32,33,34,35,36,37,41,42,43,44,45,46,50,51,52,53,54,61,62,63,64,65,71,81,82,91,";  
  482.             if (!address.Contains(input.Remove(2) + ","))  
  483.             {  
  484.                 return false;  
  485.             }  
  486.             //验证生日是否匹配  
  487.             string birthdate = input.Substring(6, 6).Insert(4, "/").Insert(2, "/");  
  488.             DateTime dt;  
  489.             if (!DateTime.TryParse(birthdate, out dt))  
  490.             {  
  491.                 return false;  
  492.             }  
  493.             return true;  
  494.         }  
  495.   
  496.         /// <summary>  
  497.         /// 验证二代身份证号（18位数，GB11643-1999标准）  
  498.         /// [长度为18位；前17位为数字，最后一位(校验码)可以为大小写x；匹配对应省份地址；生日能正确匹配；校验码能正确匹配]  
  499.         /// </summary>  
  500.         /// <param name="input">待验证的字符串</param>  
  501.         /// <returns>是否匹配</returns>  
  502.         public static bool IsIDCard18(string input)  
  503.         {  
  504.             //验证是否可以转换为正确的整数  
  505.             long l = 0;  
  506.             if (!long.TryParse(input.Remove(17), out l) || l.ToString().Length!=17 || !long.TryParse(input.Replace('x', '0').Replace('X', '0'), out l))  
  507.             {  
  508.                 return false;  
  509.             }  
  510.             //验证省份是否匹配  
  511.             //1~6位为地区代码，其中1、2位数为各省级政府的代码，3、4位数为地、市级政府的代码，5、6位数为县、区级政府代码。  
  512.             string address = "11,12,13,14,15,21,22,23,31,32,33,34,35,36,37,41,42,43,44,45,46,50,51,52,53,54,61,62,63,64,65,71,81,82,91,";  
  513.             if (!address.Contains(input.Remove(2) + ","))  
  514.             {  
  515.                 return false;  
  516.             }  
  517.             //验证生日是否匹配  
  518.             string birthdate = input.Substring(6, 8).Insert(6, "/").Insert(4, "/");  
  519.             DateTime dt;  
  520.             if (!DateTime.TryParse(birthdate, out dt))  
  521.             {  
  522.                 return false;  
  523.             }  
  524.             //校验码验证  
  525.             //校验码：  
  526.             //（1）十七位数字本体码加权求和公式   
  527.             //S = Sum(Ai * Wi), i = 0, ... , 16 ，先对前17位数字的权求和   
  528.             //Ai:表示第i位置上的身份证号码数字值   
  529.             //Wi:表示第i位置上的加权因子   
  530.             //Wi: 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2   
  531.             //（2）计算模   
  532.             //Y = mod(S, 11)   
  533.             //（3）通过模得到对应的校验码   
  534.             //Y: 0 1 2 3 4 5 6 7 8 9 10   
  535.             //校验码: 1 0 X 9 8 7 6 5 4 3 2   
  536.             string[] arrVarifyCode = ("1,0,x,9,8,7,6,5,4,3,2").Split(',');  
  537.             string[] Wi = ("7,9,10,5,8,4,2,1,6,3,7,9,10,5,8,4,2").Split(',');  
  538.             char[] Ai = input.Remove(17).ToCharArray();  
  539.             int sum = 0;  
  540.             for (int i = 0; i < 17; i++)  
  541.             {  
  542.                 sum += int.Parse(Wi[i]) * int.Parse(Ai[i].ToString());  
  543.             }  
  544.             int y = -1;  
  545.             Math.DivRem(sum, 11, out y);  
  546.             if (arrVarifyCode[y] != input.Substring(17, 1).ToLower())  
  547.             {  
  548.                 return false;  
  549.             }  
  550.             return true;  
  551.         }  
  552.   
  553.         /// <summary>  
  554.         /// 验证身份证号（不区分一二代身份证号）  
  555.         /// </summary>  
  556.         /// <param name="input">待验证的字符串</param>  
  557.         /// <returns>是否匹配</returns>  
  558.         public static bool IsIDCard(string input)  
  559.         {  
  560.             if (input.Length == 18)  
  561.                 return IsIDCard18(input);  
  562.             else if (input.Length == 15)  
  563.                 return IsIDCard15(input);  
  564.             else  
  565.                 return false;  
  566.         }  
  567.   
  568.         /// <summary>  
  569.         /// 验证经度  
  570.         /// </summary>  
  571.         /// <param name="input">待验证的字符串</param>  
  572.         /// <returns>是否匹配</returns>  
  573.         public static bool IsLongitude(string input)  
  574.         {  
  575.             ////范围为-180～180，小数位数必须是1到5位  
  576.             //string pattern = @"^[-\+]?((1[0-7]\d{1}|0?\d{1,2})\.\d{1,5}|180\.0{1,5})$";  
  577.             //return IsMatch(input, pattern);  
  578.             float lon;  
  579.             if (float.TryParse(input, out lon) && lon >= -180 && lon <= 180)  
  580.                 return true;  
  581.             else  
  582.                 return false;  
  583.         }  
  584.   
  585.         /// <summary>  
  586.         /// 验证纬度  
  587.         /// </summary>  
  588.         /// <param name="input">待验证的字符串</param>  
  589.         /// <returns>是否匹配</returns>  
  590.         public static bool IsLatitude(string input)  
  591.         {  
  592.             ////范围为-90～90，小数位数必须是1到5位  
  593.             //string pattern = @"^[-\+]?([0-8]?\d{1}\.\d{1,5}|90\.0{1,5})$";  
  594.             //return IsMatch(input, pattern);  
  595.             float lat;  
  596.             if (float.TryParse(input, out lat) && lat >= -90 && lat <= 90)  
  597.                 return true;  
  598.             else  
  599.                 return false;  
  600.         }  
  601.         #endregion  
  602.     }  
  603. }  
posted @ 2017-06-12 15:26  小伙子很浪  阅读(141)  评论(0)  编辑  收藏  举报