SimplyGold

Regular expressions are often used for user input validation. One common problem is to validate that the e-mail that the user entered is valid. There are a zillion readymade e-mail regex for your use, but I was always interested in knowing why something works, so I set about to create my own regex. That led to my making more commonly-used regular expressions, so I thought I’d share them.

Note that I’m still very much of a newbie when it comes to regular expressions, so these might not be the most efficient ways to validate the appropriate inputs. I checked that each pattern’s working using RadSoftware’s excellent RegexDesigner. It’s such a relief to not have to not have to write a test application.

Oh, the “#” you see in the regular expressions are comments.

1. using System;
2. using System.Text.RegularExpressions;
4. namespace SG.Net.Utilities
5. {
6. public class InputValidation
7. {
8. /// <summary>
9. /// A password is valid if
10. /// 1. It’s at least [minLength] long.
11. /// 2. It has at least one uppercase letter.
12. /// 3. It has at least one lowercase letter.
13. /// 4. It has at least one digit.
14. /// 5. It has at least one non-alphanumeric character.
15. /// </summary>
16. /// <param name="password">The password to validate.</param>
17. /// <param name="minLength">Minimum length of the password.</param>
18. /// <returns>True if the password is valid, false otherwise.</returns>
19. public static bool ValidatePassword(string password, int minLength)
20. {
21. Regex pattern = new Regex(@"
23. ^ # Match the start of string
24. (?=.*d) # Do we have at least one digit?
25. (?=.*[A-Z]) # Do we have at least one uppercase letter?
26. (?=.*[a-z]) # Do we have at least one lowercase letter?
27. (?=.*[^a-zA-Z0-9nrt ]) # Do we have at least one non-alphanumeric character?
28. .{" + minLength.ToString() + @",} # Is it at least 6 characters long?
29. $ # Match the end of the string
31. ", RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace);
33. return pattern.IsMatch(password);
34. }
36. /// <summary>
37. /// An email is valid if
38. /// 1. It contains an ‘@’ symbol.
39. /// 2. It contains a ‘.’ symbol.
40. /// 3. There are alphanumeric characters (or certain symbols) in front of the ‘@’ symbol.
41. /// 4. There are alphanumeric characters in between ‘@’ and ‘.’ symbols.
42. /// 5. There are alpha characters after the ‘.’ symbol.
43. /// </summary>
44. /// <param name="email">The email address to validate.</param>
45. /// <returns>True if email is valid, false otherwise.</returns>
46. /// <remarks>
47. /// This function supports multiple subdomains.
48. /// Check http://www.ietf.org/rfc/rfc2822.txt for generic syntax of emails
49. /// </remarks>
50. public static bool ValidateEmail(string email)
51. {
52. Regex pattern = new Regex(@"
54. ^ # Match the beginning of the string
55. [a-zA-Z0-9]+ # Start with an alphanumeric character
56. [a-zA-Z0-9!`#$^&*]* # Allow for any number of approved symbols
57. @ # Match the ‘@’ symbol
58. [a-zA-Z0-9]+ # One or more alphanumeric characters
59. [a-zA-Z0-9.]* # Allow for subdomains
60. . # Match the ‘.’ symbol
61. [a-zA-Z]+ # Match the domain
62. $ # Match the end of the string
64. ", RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace);
66. return pattern.IsMatch(email);
67. }
69. /// <summary>
70. /// A social security number is valid if it’s 9 digits long.
71. /// </summary>
72. /// <param name="ssn">The social security number to validate.</param>
73. /// <returns>True if the ssn is valid, false otherwise. </returns>
74. public static bool ValidateSSN(string ssn)
75. {
76. //Strip the seperators (for example, ‘-’). It’s so much easier to code the regular
77. //expression when we don’t have to handle the seperators (which the user may or may
78. //not have entered.
79. ssn.Trim().Replace("-", String.Empty).Replace(".", String.Empty).Replace(" ", String.Empty);
81. return Regex.IsMatch(ssn, @"^d{9}$");
82. }
84. /// <summary>
85. /// A phone number is valid if it is 6 or 9 digits long.
86. /// </summary>
87. /// <param name="phoneNumber">The phone number to validate.</param>
88. /// <returns>True if phone number is valid, false otherwise.</returns>
89. /// <remarks>Obviously, this doesn’t allow for international phone numbers.</remarks>
90. public static bool ValidatePhoneNumber(string phoneNumber)
91. {
92. //Valid phone numbers, for example, include:
93. //1. (999)-999-9999
94. //2. (999)999-9999
95. //3. 999-999-9999
96. //4. 9999999999
97. //So we’ll once again strip the seperators to make our lives easier.
98. //(), ‘-’, ‘.’, and ‘ ‘ are considered valid seperators.
99. phoneNumber.Trim().Replace("(", String.Empty).Replace(")", String.Empty).
100. Replace("-", String.Empty).Replace(".", String.Empty).
101. Replace(" ", String.Empty);
103. return ((Regex.IsMatch(phoneNumber, @"^d{9}$") || Regex.IsMatch(phoneNumber, @"^d{6}$")));
104. }
106. /// <summary>
107. /// Validates a date using C#-built in DateTime.TryParse()
108. /// function.
109. /// </summary>
110. /// <param name="date">The date to validate</param>
111. /// <returns>True if the date is valid, false otherwise.</returns>
112. public static bool ValidateDate(string date)
113. {
114. //Dates can be entered in a couple of different formats:
115. //1. 2006-03-04
116. //2. 03-04-2006
117. //3. April 3 2006
118. //4. April 3, 2006
119. //5. Apr 3, 2006
120. //6. 03-APR-2006
121. //7. 3-APR-06
122. //You get the idea.
123. //It’s probably doable with regular expressions, but we
124. //might as well use C#’s awesome DateTime.Parse(string date)
125. //method to validate the date.
127. DateTime dateParsed = new DateTime();
129. return DateTime.TryParse(date, out dateParsed);
130. }
132. /// <summary>
133. /// An IP Address is valid if it’s 10 digits long.
134. /// </summary>
135. /// <param name="ipaddress">The IP Address to validate</param>
136. /// <returns>True if IP Address is valid, false otherwise.</returns>
137. public static bool ValidateIPAddress(string ipaddress)
138. {
139. //We’re only going to allow the ‘.’ for a seperator.
140. ipaddress.Trim().Replace(".", String.Empty);
142. //We’ll also strip the ‘http://’, ‘https://’, or ‘ftp://’
143. ipaddress.Replace("http://", String.Empty).Replace("https://", String.Empty).
144. Replace("ftp://", String.Empty);
146. return Regex.IsMatch(ipaddress, @"^d{10}$");
147. }
149. /// <summary>
150. /// Validates most forms of urls.
151. /// </summary>
152. /// <param name="url">The URL to validate</param>
153. /// <returns>True if the URL is valid, false otherwise.</returns>
154. /// <remarks>Check http://www.ietf.org/rfc/rfc2396.txt for generic syntax of URLs.</remarks>
155. public static bool ValidateURL(string url)
156. {
157. //Valid urls include:
158. //1. http://www.awesomesite.com/
159. //2. http://awesomesite.com/
160. //3. www.awesomesite.com
161. //4. www.awesomesubdomain.awesomesite.com
162. //5. http://www.awesomesite.com/awesomepage.aspx
163. //6. ftp://awesomesite.com
164. //7. 999.999.999 (IP Address)
165. //8. https://awesomesite.com/
166. //9. awesomesite.com
167. //10. http://999.999.999
168. //Substitute whatever domain name you want for the ‘com’
170. //We’ll check for the domain case first, and the ip address case
171. //second.
172. Regex pattern = new Regex(@"
174. ^ # Match start of string
175. ( # Match one of
176. ftp://| # these
177. https://| # three
178. http:// # characters
179. )? # (optional); followed
180. (www.)? # optionally by the string ‘www.’ followed by
181. [A-Za-z0-9]+ # one or more alphanumeric characters
182. [A-Za-z0-9.]* # Allow for subdomains
183. . # Match the ‘.’ symbol
184. [A-Za-z]+ # Followed by one or more alphanumeric characters
185. /? # Followed by an optional (closing) slash
186. (
187. /[A-Za-z0-9/]+ # Allow for pages
188. . # Match the ‘.’ symbol
189. [A-Za-z0-9/]+ # Match the page’s extension
190. )? # All of which is optional, of course
191. $ # Match end of string
192. ", RegexOptions.Multiline | RegexOptions.IgnorePatternWhitespace);
194. if(pattern.IsMatch(url))
195. return true;
197. //Let’s now try to check for the IP Address case
198. return InputValidation.ValidateIPAddress(url);
199. }
200. }
201. }