.NET Regular Expressions Demystified - Part One

1. “Important:” literally speaking it will find ‘important’ as it is
   The regular expression pattern, which is a very simple form of the regular expression, will find the match for 9 words ‘I’, ’m’, ’p’, ’o’, ’r’, ’t’, ’a’, ’n’, ’t’ in the exact same sequence as they are written above. If there are some characters before and after the sequence other than space, inappropriately, it will find those matches too, words like unimportant, very-important and important, etc.
   
   We saw in the above example the weak point of our expression. Now, let’s improve our expression. Therefore, we can get what we actually want.
2. “\bimportant\b” now it will find ‘important’ as a whole word
   Now we have improved our expression by adding ‘\b’ before and after it. As you are already familiar with ‘\b’ from the above table,‘\b’ is a special character that tells the regular expressions engine to please start finding a match for that particular expression at the beginning of the word and stops at the ending of the word. In simple terms ‘\b’ represents the position at the beginning and end of the word.
   1. ```csharp
   2. class JustFind
   3. {
   4. static void Main(string[] args)
   5. {
   6. string pattern = @"\bimportant\b";
   7. string inputString = "Some important text to find unimportant stuff";
   8. Regex regex = new Regex(pattern, RegexOptions.IgnoreCase);
   9. MatchCollection matches=regex.Matches(inputString);
   10. Console.WriteLine("\tAll Matches");
   11. foreach (var match in matches)
   12. {
   13. Console.WriteLine(match);
   14. }
   15. Console.ReadLine();
   16. }
   17. }
   18. ```
   Result
   
   Now, you can see from the snapshot given above, we got only one result back.
3. Example of ‘\s’ character
   Here, we will explain an example, where we will use ‘\s’ character to explain the purpose and use of that particular character. As I mentioned above in the special characters table, that ‘\s’ character is used to represent a white space character in the text. With the use of ‘\s’, we will create a regular expression, that will help us to replace the spaces between the words with ’_’ character.
   1. ```csharp
   2. class JustFind
   3. {
   4. static void Main(string[] args)
   5. {
   6. string pattern = @"\s";
   7. string inputString = "Some important text to find unimportant stuff";
   8. Regex regex = new Regex(pattern, RegexOptions.IgnoreCase);
   9. string result = regex.Replace(inputString, "_");
   10. Console.WriteLine(result);
   11. Console.ReadLine();
   12. }
   13. }
   14. ```
   Result
   
4. Finding Number Words in string ("\b\w+\b").
   In this example, we will write an expression that’s going to help us to find the number of words in a particular text input. In any text or document, the words are separated by a space character, so in that case, the space character will help us to find our words. The above will skip the spaces b/w words and will pick up every word that starts and ends with any alphanumeric character and must have 1 or more characters inside.

   Expression	Description
   \b	means start with
   \b\w	means start with any alphanumeric character
   \b\w+	means start with any alphanumeric character and repeats the previous match 1 or more times (in simple terms it means the word we are going to match must contain at least one character)
   \b\w +\b	In the end \b means the word also must end with an alphanumeric character

   1. ``
   2. `csharp
   3. class JustFind
   4. {
   5. static void Main(string[] args)
   6. {
   7. string pattern = @"\b\w+\b";
   8. string inputString = "Some important text to find unimportant stuff";
   9. Regex regex = new Regex(pattern, RegexOptions.IgnoreCase);
   10. inttotalWords = regex.Matches(inputString).Count;
   11. Console.WriteLine($"Words Count: {totalWords}");
   12. Console.ReadLine();
   13. }
   14. }
   15. `
   16. ``
   Result
   

Summary