using System.Text;
using System.Text.RegularExpressions;
namespace Demo.Code
{
public class Validate
{
private static Regex RegNumber = new Regex("^[0-9]+$");
private static Regex RegNumberSign = new Regex("^[+-]?[0-9]+$");
private static Regex RegDecimal = new Regex("^[0-9]+[.]?[0-9]+$");
private static Regex RegDecimalSign = new Regex("^[+-]?[0-9]+[.]?[0-9]+$"); //equivalent to ^[+-]?\d+[. ]?\d+$
private static Regex RegEmail = new Regex(@"^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$"); //w string of English letters or numbers, same as [a-zA-Z0-9] syntax
private static Regex RegCHZN = new Regex("[\u4e00-\u9fa5]");
#region Username Password Format
/// <summary>
/// Returns the real length of the string, the length of 1 Chinese character is 2
/// </summary>
/// <returns>Character length</returns>
public static int GetStringLength(string stringValue)
{
return Encoding.Default.GetBytes(stringValue).Length;
}
/// <summary>
/// Check if the username format is valid
/// </summary>
/// <param name="userName"></param>
/// <returns></returns>
public static bool IsValidUserName(string userName)
{
int userNameLength = GetStringLength(userName);
if (userNameLength >= 4 && userNameLength <= 20 && Regex.IsMatch(userName, @"^([\u4e00-\u9fa5A-Za-z_0-9]{0,})$"))
{ // Determine whether the length (4-20 characters) and content of the username (only Chinese characters, letters, underscores, numbers) are legal
return true;
}
else
{
return false;
}
}
/// <summary>
/// Password validity
/// </summary>
/// <param name="password"></param>
/// <returns></returns>
public static bool IsValidPassword(string password)
{
return Regex.IsMatch(password, @"^[A-Za-z_0-9]{6,16}$");
}
#endregion
#region Numeric String Check
/// <summary>
/// int validity
/// </summary>
/// <param name="val"></param>
/// <returns></returns>
static public bool IsValidInt(string val)
{
return Regex.IsMatch(val, @"^[1-9]\d*\.?[0]*$");
}
/// <summary>
/// Is it a numeric string
/// </summary>
/// <param name="inputData">input string</param>
/// <returns></returns>
public static bool IsNumber(string inputData)
{
Match m = RegNumber.Match(inputData);
return m.Success;
}
/// <summary>
/// Whether the number string can be signed
/// </summary>
/// <param name="inputData">input string</param>
/// <returns></returns>
public static bool IsNumberSign(string inputData)
{
Match m = RegNumberSign.Match(inputData);
return m.Success;
}
/// <summary>
/// Whether it is a floating point number
/// </summary>
/// <param name="inputData">input string</param>
/// <returns></returns>
public static bool IsDecimal(string inputData)
{
Match m = RegDecimal.Match(inputData);
return m.Success;
}
/// <summary>
/// Whether it is a floating point number can be signed
/// </summary>
/// <param name="inputData">input string</param>
/// <returns></returns>
public static bool IsDecimalSign(string inputData)
{
Match m = RegDecimalSign.Match(inputData);
return m.Success;
}
#endregion
#region Chinese detection
/// <summary>
/// Check if there are Chinese characters
/// </summary>
/// <param name="inputData"></param>
/// <returns></returns>
public static bool IsHasCHZN(string inputData)
{
Match m = RegCHZN.Match(inputData);
return m.Success;
}
/// <summary>
/// Detect the actual length of Chinese strings
/// </summary>
/// <param name="str">字符串</param>
public static int GetCHZNLength(string inputData)
{
System.Text.ASCIIEncoding n = new System.Text.ASCIIEncoding();
byte[] bytes = n.GetBytes(inputData);
int length = 0; // l is the actual length of the string
for (int i = 0; i <= bytes.Length - 1; i++)
{
if (bytes[i] == 63) //Determine whether it is a Chinese character or a full foot symbol
{
length++;
}
length++;
}
return length;
}
#endregion
#region Common Format
/// <summary>
/// Verify whether the ID card is legal 15 and 18 digits
/// </summary>
/// <param name="idCard">ID to verify</param>
public static bool IsIdCard(string idCard)
{
if (string.IsNullOrEmpty(idCard))
{
return false;
}
if (idCard.Length == 15)
{
return Regex.IsMatch(idCard, @"^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$");
}
else if (idCard.Length == 18)
{
return Regex.IsMatch(idCard, @"^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])((\d{4})|\d{3}[A-Z])$", RegexOptions.IgnoreCase);
}
else
{
return false;
}
}
/// <summary>
/// Is it an email address?
/// </summary>
/// <param name="inputData">input string</param>
/// <returns></returns>
public static bool IsEmail(string inputData)
{
Match m = RegEmail.Match(inputData);
return m.Success;
}
/// <summary>
/// Zip code validity
/// </summary>
/// <param name="zip"></param>
/// <returns></returns>
public static bool IsValidZip(string zip)
{
Regex rx = new Regex(@"^\d{6}$", RegexOptions.None);
Match m = rx.Match(zip);
return m.Success;
}
/// <summary>
/// Landline validity
/// </summary>
/// <param name="phone"></param>
/// <returns></returns>
public static bool IsValidPhone(string phone)
{
Regex rx = new Regex(@"^(\(\d{3,4}\)|\d{3,4}-)?\d{7,8}$", RegexOptions.None);
Match m = rx.Match(phone);
return m.Success;
}
/// <summary>
/// Phone validity
/// </summary>
/// <param name="strMobile"></param>
/// <returns></returns>
public static bool IsValidMobile(string mobile)
{
Regex rx = new Regex(@"^(13|15|17|18|19)\d{9}$", RegexOptions.None);
Match m = rx.Match(mobile);
return m.Success;
}
/// <summary>
/// Phone availability (landline and mobile)
/// </summary>
/// <param name="strVla"></param>
/// <returns></returns>
public static bool IsValidPhoneAndMobile(string number)
{
Regex rx = new Regex(@"^(\(\d{3,4}\)|\d{3,4}-)?\d{7,8}$|^(13|15)\d{9}$", RegexOptions.None);
Match m = rx.Match(number);
return m.Success;
}
/// <summary>
/// Url validity
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
static public bool IsValidURL(string url)
{
return Regex.IsMatch(url, @"^(http|https|ftp)\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(:[a-zA-Z0-9]*)?/?([a-zA-Z0-9\-\._\?\,\'/\\\+&%\$#\=~])*[^\.\,\)\(\s]$");
}
/// <summary>
/// IP validity
/// </summary>
/// <param name="ip"></param>
/// <returns></returns>
public static bool IsValidIP(string ip)
{
return Regex.IsMatch(ip, @"^((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)$");
}
/// <summary>
/// domain validity
/// </summary>
/// <param name="host">域名</param>
/// <returns></returns>
public static bool IsValidDomain(string host)
{
Regex r = new Regex(@"^\d+$");
if (host.IndexOf(".") == -1)
{
return false;
}
return r.IsMatch(host.Replace(".", string.Empty)) ? false : true;
}
/// <summary>
/// Determine if it is a base64 string
/// </summary>
/// <param name="str"></param>
/// <returns></returns>
public static bool IsBase64String(string str)
{
return Regex.IsMatch(str, @"[A-Za-z0-9\+\/\=]");
}
/// <summary>
/// Verify that the string is a GUID
/// </summary>
/// <param name="guid">string</param>
/// <returns></returns>
public static bool IsGuid(string guid)
{
if (string.IsNullOrEmpty(guid))
return false;
return Regex.IsMatch(guid, "[A-F0-9]{8}(-[A-F0-9]{4}){3}-[A-F0-9]{12}|[A-F0-9]{32}", RegexOptions.IgnoreCase);
}
#endregion
#region Date Check
/// <summary>
/// Determine if the input character is a date
/// </summary>
/// <param name="strValue"></param>
/// <returns></returns>
public static bool IsDate(string strValue)
{
return Regex.IsMatch(strValue, @"^((\d{2}(([02468][048])|([13579][26]))[\-\/\s]?((((0?[13578])|(1[02]))[\-\/\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\-\/\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\-\/\s]?((0?[1-9])|([1-2][0-9])))))|(\d{2}(([02468][1235679])|([13579][01345789]))[\-\/\s]?((((0?[13578])|(1[02]))[\-\/\s]?((0?[1-9])|([1-2][0-9])|(3[01])))|(((0?[469])|(11))[\-\/\s]?((0?[1-9])|([1-2][0-9])|(30)))|(0?2[\-\/\s]?((0?[1-9])|(1[0-9])|(2[0-8]))))))");
}
/// <summary>
/// Determine whether the input character is a date, such as 2004-07-12 14:25|||1900-01-01 00:00|||9999-12-31 23:59
/// </summary>
/// <param name="strValue"></param>
/// <returns></returns>
public static bool IsDateHourMinute(string strValue)
{
return Regex.IsMatch(strValue, @"^(19[0-9]{2}|[2-9][0-9]{3})-((0(1|3|5|7|8)|10|12)-(0[1-9]|1[0-9]|2[0-9]|3[0-1])|(0(4|6|9)|11)-(0[1-9]|1[0-9]|2[0-9]|30)|(02)-(0[1-9]|1[0-9]|2[0-9]))\x20(0[0-9]|1[0-9]|2[0-3])(:[0-5][0-9]){1}$");
}
#endregion
#region Other
/// <summary>
/// Check the maximum length of the string and return a string of the specified length
/// </summary>
/// <param name="sqlInput">input string</param>
/// <param name="maxLength">maximum length</param>
/// <returns></returns>
public static string CheckMathLength(string inputData, int maxLength)
{
if (inputData != null && inputData != string.Empty)
{
inputData = inputData.Trim();
if (inputData.Length > maxLength)//Truncate the string according to the maximum length
{
inputData = inputData.Substring(0, maxLength);
}
}
return inputData;
}
/// <summary>
/// Convert to HTML code
/// </summary>
/// <param name="str">string</param>
/// <returns>string</returns>
public static string Encode(string str)
{
str = str.Replace("&", "&");
str = str.Replace("'", "''");
str = str.Replace("\"", """);
str = str.Replace(" ", " ");
str = str.Replace("<", "<");
str = str.Replace(">", ">");
str = str.Replace("\n", "<br>");
return str;
}
/// <summary>
///Parse html into normal text
/// </summary>
/// <param name="str">string</param>
/// <returns>string</returns>
public static string Decode(string str)
{
str = str.Replace("<br>", "\n");
str = str.Replace(">", ">");
str = str.Replace("<", "<");
str = str.Replace(" ", " ");
str = str.Replace(""", "\"");
return str;
}
#endregion
}
}
[Reproduced] Commonly used regular expression to verify the string class
Guess you like
Origin http://43.154.161.224:23101/article/api/json?id=326483973&siteId=291194637
Recommended
Ranking