原文:验证（C#和正则表达式）

我们经常会需要验证字符串的格式，比如密码长度范围、电子邮件格式、固定电话号码和手机号码格式等，这个时候我们经常会需要用到正则表达式。但是正则表达式用起来性能会低一点，所以在需要验证的时候能不使用正则表达式还是尽量不要使用正则表达式。

下面贴出来我写的一个验证类，里面包含了一些常用的验证。在这些验证里，能不用正则表达式验证的都尽量没有用正则表达式，但是在这种情况下都尽量把用正则表达式验证的代码也写在了方法里面做了注释。

ps:Javascript版请点这里。

正则表达式验证需要引用System.Text.RegularExpressions命名空间。

  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\d{2}\)|0\d{2})[- ]?)?\d{8}|((\(0\d{3}\)|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\d{2}\)|0\d{2})[- ]?)?\d{8}|((\(0\d{3}\)|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. }

验证（C#和正则表达式）的更多相关文章

  1. js 验证数字的正则表达式集

    <script type="text/javascript">     function validate(){       var reg = new RegExp( ...

  2. C# 验证数字的正则表达式集

    验证数字的正则表达式集 博客分类: 正则 正则表达式 验证数字的正则表达式集 验证数字:^[0-9]*$ 验证n位的数字:^\d{n}$ 验证至少n位数字:^\d{n,}$ 验证m-n位的数字:^\d ...

  3. js验证电话号码的正则表达式

    在做程序时遇到js验证电话号码的问题,使用正则表达式来操作很简单的.一起来看一下吧. 1,这种是比较简单的验证号码: 电话号码只能包含”(“.“)”.“-”和数字 <input   type=t ...

  4. Android版：验证手机号码的正则表达式 （转）

    /**  * 验证手机格式  */  public static boolean isMobileNO(String mobiles) {      /*     移动:134.135.136.137 ...

  5. Android版：验证手机号码的正则表达式

    http://blog.csdn.net/dai_zhenliang/article/details/8186249 /** * 验证手机格式 */ public static boolean isM ...

  6. php的一个验证邮箱的正则表达式

    /([a-z0-9]*[-_\.]*[a-z0-9]+)*[-_\.]*@([a-z0-9]*[-_]?[a-z0-9]+)+[\.]([a-z0-9]{2,3}|[a-z0-9]*[-_]?[a-z ...

  7. 前台ajax验证技术采用正则表达式

    var flag1,flag2,flag3,flag4,flag5,flag6=false; function val(obj) { var regBox = { /* regEmail : /^([ ...

  8. textbox只能输入数字或中文的常用正则表达式和验证方法

    验证数字的正则表达式集 验证数字:^[0-9]*$ 验证n位的数字:^\d{n}$ 验证至少n位数字:^\d{n,}$ 验证m-n位的数字:^\d{m,n}$ 验证零和非零开头的数字:^(0|[1-9 ...

  9. JS正则表达式验证数字

    <script type="text/javascript"> function validate(){ var reg = new RegExp("^[0- ...

  10. HTML(六)——表单验证、正则表达式、事件

    1.表单验证<form></form> (1).非空验证(去空格) (2).对比验证(跟一个值对比) (3).范围验证(根据一个范围进行判断) (4).固定格式验证:电话号码, ...

随机推荐

  1. NUnit3 Test Adapter vs2015

    NUnit的安装 前言:NUnit是什么? NUnit 是一个单元测试框架,专门针对于.NET来写的.NUnit是xUnit家族种的第4个主打产品,完全由C#语言来编写,并且编写时充分利用了许多.NE ...

  2. Java Web系列：Spring Boot 基础 （转）

    Spring Boot 项目(参考1) 提供了一个类似ASP.NET MVC的默认模板一样的标准样板,直接集成了一系列的组件并使用了默认的配置.使用Spring Boot 不会降低学习成本,甚至增加了 ...

  3. 国外流行的共享网站实现：facebook，twitter，google+1，tumblr等待

    近期需要做相关的国外几个站点共享,本来我以为它会和weibo.在同样的烦恼空间,什么appkey啦,apptoken啦.api啦.结果非常意外的发现并非如此恼火. Twitter分享: https:/ ...

  4. 弹出层 div dialog

    写你自己的弹出框 风格,如下面 watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvcWluZ2xpYW5sdWFu/font/5a6L5L2T/fontsize ...

  5. Docker简明教程（转）

    Docker自从诞生以来就一直备受追捧,学习Docker是一件很炫酷.很有意思的事情.我希望通过这篇文章能够让大家快速地入门Docker,并有一些学习成果来激发自己的学习兴趣.我也只是一个在Docke ...

  6. Android4.4 蓝牙源代码段分析

    最近GOOGLE发布时间Android4.4,我看了看源代码.4.4蓝牙打开过程或这部分的一些变化,判断蓝牙开关是从接口设置settings在里面switch开关,widget当然,它可以切换,也许启 ...

  7. Linux的NTP配置总结（转）

    在Linux系统中,为了避免主机时间因为在长时间运行下所导致的时间偏差,进行时间同步(synchronize)的工作是非常必要的.Linux系统下,一般使用ntp服务来同步不同机器的时间.NTP 是网 ...

  8. （大数据工程师学习路径）第四步 SQL基础课程----修改和删除

    一.准备 在正式开始本内容之前,需要先从github下载相关代码.该代码可以新建两个数据库,分别名为test_01和mysql_shiyan ,并在mysql_shiyan数据库中建4个表(depar ...

  9. hdu 4919 Exclusive or

    Exclusive or Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) T ...

  10. ORA-12638: 无法检索身份证明 解决的方法

    the NTS option makes the Oracle client attempt to use your current Windows domain credentials to aut ...