Gain insights into pattern matching with regular expressions in C#. Explore data validation, information extraction, and more using String and Regex APIs with practical examples.

Regular expressions provide an extremely powerful method for pattern matching with strings. They are very useful for parsing information like dates, phone numbers, or zip codes from important text files, such as code files, log files, spreadsheets, or documents. The course discusses everyday use cases of regular expressions, e.g., data validation, information extraction, pattern matching, and search and replace.

This course will teach you the core concepts of pattern matching, character classes, special and meta characters, and quantifiers. You will also learn conditional regular expressions including lookahead and lookbehind assertions. You will also learn the APIs used in C# for regular expressions with hands-on code widgets. 

This course will teach you how to perform pattern matching with a regular expression using String and Regex APIs for the above-mentioned practical use cases in C#.

Tarun Telang

Tarun Telang is a passionate software engineer, leader, architect, author, and active contributor in various online technical forums.

C# and Microsoft Expert

Working with Regular Expressions in C#

Groups are a way of subdividing the match that regular expressions find. We specify groups with parentheses in regular expressions.

![](/api/collection/5747246075215872/4665898056548352/page/6700367827435520/image/5040527808659456?page_type=collection_lesson)




For example, we have the following input string:

```txt
The quick brown fox jumps over the lazy dog.
```
To match all the words in this string, we use the following regular expression:


using System.Text.RegularExpressions;

class HelloWorld
{
    static void Main()
    {
      string text = "The quick brown fox jumped over the lazy dog.";
      Match match = Regex.Match(text, "\\w+");
      System.Console.WriteLine(match.Groups[0]);
    }
}

The regular expression `\w+` matches the first word `The`. However, what if we want to match only the first three words? We can use a group for this:

```
(\w+) (\w+) (\w+)
```

This regular expression matches “The quick brown.”

# Accessing group matches in C#

Once a match is found, we can access groups using the `Groups` property of the `Match` object. The `Groups` property returns a collection of `Groups` objects.

The following code shows how to access the groups in a match:

```
Match match = Regex.Match("The quick brown fox", "(\\w+) (\\w+) (\\w+)");
foreach (Group group in match.Groups)
{
    Console.WriteLine(group);
}
```

This code outputs the following:

```txt
The quick brown
The
quick
brown
```

Group 0 always contains the entire match. Meanwhile, Group 1 contains the first capture group, Group 2 contains the second capture group, and so on.

## Numbering and naming groups

We can either reference groups by numbers, or by their name. We can number them from left to right, starting at 1. So, in the previous example, the first group is Group 1, the second group is Group 2, and the third group is Group 3.

>**Note**: If we don’t give a group a name, we cannot access it by name. We can only access it by number



Learn how to use groups with regular expressions.

Introduction

Building Blocks of .NET Regular Expressions

Advanced Concepts

Course Wrap Up

Using Regular Expressions in C# with Groups

Groups