Regex Options In C#: A Beginner’s Guide To Powerful Pattern Matching
Tags: regex, csharp, coding, programming
Published: 2024-04-09 16:00:00

Regular expressions are incredibly powerful both at matching string patterns and for giving developers headaches. Some days, I’m not sure what they do a better job of! In C#, when we’re working with regular expressions we get a handful of methods to use, but we can also configure the regular expressions to behave differently. In this article, we’ll look at regex options in C# together by walking through some introductory regex methods that we have access to and then seeing these regex options in action.

And don’t worry: Not only are there code examples that you can copy and paste, but you can try them out right in your browser thanks to DotNetFiddle.

---

## **What is a Regular Expression?**

Regular expressions, often referred to as regex, are powerful tools used for pattern matching in text. They allow you to define a search pattern that can be used to find, replace, or manipulate specific parts of a string. Regular expressions provide a concise and flexible way to search for and identify specific patterns within text data.

In software engineering, [regular expressions](https://www.devleader.ca/?p=6912) are particularly useful for tasks such as data validation, text parsing, and pattern extraction. They can be used in a wide range of scenarios, including web development, data processing, and text analysis. Regular expressions can save you time and effort by providing a more efficient and reliable approach to handling text manipulation tasks.

Here are a bunch of practical examples you could consider using a [regular expression](https://www.devleader.ca/2024/04/02/regular-expressions-in-csharp-3-examples-you-need-to-know/) for:

1. **Validating Email Addresses**: Say you are developing a web application that requires users to provide valid email addresses during the registration process. With regular expressions, you can quickly validate if an email address provided by the user adheres to the standard format, ensuring its correctness before further processing.
    
2. **Searching and Replacing Text**: Imagine you have a large document and need to replace all occurrences of a particular word or phrase with another. Instead of manually searching through the entire document, you can use regular expressions to perform the substitution task efficiently and accurately.
    
3. **Extracting Data from Text**: Suppose you have a log file containing lines of data, but you are only interested in retrieving specific pieces of information, such as timestamps or error messages. Regular expressions enable you to extract the relevant data by identifying patterns within the log entries, saving you valuable time when analyzing and troubleshooting issues.
    

These are just a few examples of how regular expressions can be leveraged in your applications. In C#, the .NET framework provides a regex library that offers us the power to match all sorts of strings that we’re interested in. In the following sections, I’ll provide code examples for how to work with regular expressions in C#.

{% embed https://weekly.devleader.ca/embed %} 

---

## **Getting Started with Regular Expressions in CSharp**

To begin using regular expressions in C#, you need to understand how to create and work with Regex objects, which are part of the System.Text.RegularExpressions namespace. So to start, let’s get this namespace included in your C# code. You can do this by adding the following using statement at the top of your C# file:

```csharp
using System.Text.RegularExpressions;
```

Once you have included the namespace, you can create a Regex object to represent your regular expression pattern. The Regex class provides various constructors that allow you to specify the pattern and any additional options — but we’ll just start with the default C# regex options for now. For example, to create a Regex object that matches the word “hello” in a string, you can use the following code:

```csharp
Regex regex = new Regex("hello");
```

### **Using Regex.Match in CSharp**

After creating the Regex object, you can use its methods to perform pattern-matching operations on strings. The most commonly used method is `Match`, which searches for the first occurrence of the pattern in a given string. Here is a basic example that demonstrates how to use regular expressions for pattern matching in C#:

```csharp
using System;
using System.Text.RegularExpressions;

string input = "Hello, World!";
Regex regex = new Regex("Hello");
Match match = regex.Match(input);

if (match.Success)
{
    Console.WriteLine($"Pattern found: {match.Value}");
}
else
{
    Console.WriteLine("Pattern not found.");
}
```

In this example, we create a Regex object to match the word “Hello” and then use the `Match` method to search for a match in the input string “Hello, World!”. The `Match` method returns a `Match` object, which contains information about the first occurrence of the pattern. We can use the `Success` property to check if a match was found and the `Value` property to retrieve the matched string.

You can check out [this DotNetFiddle to run this C# regex example](https://dotnetfiddle.net/MnMJzL) right in your browser!

{% embed https://dotnetfiddle.net/MnMJzL %}

### **Using Regex.Matches in CSharp**

What happens if we want to match more than one part of the input string though? That’s where the `Matches` method comes into play, which will also give us a `MatchCollection` return type to work with. Let’s see it in action:

```csharp
using System;
using System.Text.RegularExpressions;

string input = "Hello, World!";
Regex regex = new Regex("Hello");
MatchCollection matches = regex.Matches(input);

if (matches.Count > 0)
{
	Console.WriteLine("Pattern(s) found:");
	foreach (Match match in matches)
	{
		Console.WriteLine($"t {match.Value}");
	}
}
else
{
    Console.WriteLine("Pattern not found.");
}
```

You can see in the example above that if we can enumerate the collection of matches instead of just dealing with a single. And if you want to try it for yourself and experiment, you can [use this dotnetfiddle to run the example of Regex.Matches in C#](https://dotnetfiddle.net/jXDGrz):

{% embed https://dotnetfiddle.net/jXDGrz %}

---

## **The Various Regex Options in CSharp**

When working with regular expressions in C#, there are several options that can be used to modify the behavior of the pattern matching. These options are defined by the `RegexOptions` enumeration in C#. [Because this is a flag enum](https://www.devleader.ca/2023/11/15/enums-in-csharp-a-simple-guide-to-expressive-code/), we can combine the different enum values to mix and match these C# regex options to get the desired behavior we want.

Let’s take a closer look at some commonly used options and understand their use in different scenarios so that you can make informed decisions and leverage regex in C# more effectively!

### **RegexOptions.Compiled**

This option improves performance by precompiling the regular expression pattern into an assembly. It’s especially useful when the same regular expression pattern is used repeatedly. By compiling the pattern once, subsequent matches can be performed more efficiently. To use this option, simply add RegexOptions.Compiled as a parameter when creating your Regex object.

Let’s consider an example where we could [benchmark the results](https://www.devleader.ca/2023/03/17/shocking-results-from-collection-and-iterator-benchmarks/) of using this option or not using BenchmarkDotNet:

```csharp
using System;
using System.Text.RegularExpressions;

using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
[ShortRunJob]
public sealed class EmailValidationBenchmark
{
    // NOTE: you could (should) extend this example
    // to try out all sorts of emails and collections
    // of emails!
    private const string TestEmail = "example@example.com";
    private const string Pattern = @"^[a-zA-Z0-9._+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}$";

    private static readonly Regex EmailRegexCompiled = new Regex(
        Pattern,
        RegexOptions.Compiled
    );

    private static readonly Regex EmailRegexNonCompiled = new Regex(
        Pattern
    );

    [Benchmark]
    public bool ValidateEmailWithCompiledOption()
    {
        return EmailRegexCompiled.IsMatch(TestEmail);
    }

    [Benchmark(Baseline = true)]
    public bool ValidateEmailWithoutCompiledOption()
    {
        return EmailRegexNonCompiled.IsMatch(TestEmail);
    }
}

class Program
{
    static void Main(string[] args)
    {
        var summary = BenchmarkRunner.Run<EmailValidationBenchmark>();
    }
}
```

Try this example out — or, better yet, try setting up a benchmark like this for your own regex and seeing if compiled makes a difference for you! Do you notice if there’s a difference in memory usage or just runtime?

Next question for you to try in your benchmarks: Do you want to be creating a new regex with the compiled flag on every time you use it, or is there performance overhead for doing that? Measure it and see if there’s a benefit to doing the compilation of the regex ONCE and storing that regex in an instance variable for re-use!

### **RegexOptions.IgnoreCase**

This option enables case-insensitive matching, allowing the regular expression pattern to match both uppercase and lowercase characters. This is important to note, because if you weren’t already aware — yes, regex is going to be case-sensitive. Hopefully you haven’t had too many headaches over this yet!

By using this option, when searching for the word “apple” using the pattern “apple”, enabling RegexOptions.IgnoreCase would match “apple”, “Apple”, and “APPLE”. To use this option, include RegexOptions.IgnoreCase as a parameter when creating your Regex object. We can see this in action in the following example:

```csharp
using System;
using System.Text.RegularExpressions;


string input1 = "I love eating apples!";
string input2 = "APPLES are great for health.";
string input3 = "Have you seen my Apple?";

Console.WriteLine($"Input 1 contains 'apple': {ContainsApple(input1)}");
Console.WriteLine($"Input 2 contains 'apple': {ContainsApple(input2)}");
Console.WriteLine($"Input 3 contains 'apple': {ContainsApple(input3)}");

static bool ContainsApple(string input)
{
    // hmmm... should we have pulled this out
    // and used the compiled flag?
    Regex appleRegex = new Regex(
        "apple",
        RegexOptions.IgnoreCase);
    return appleRegex.IsMatch(input);
}
```

### **RegexOptions.Multiline**

This option changes the behavior of the ^ and $ anchors when used in the pattern. By default, ^ matches the start of the input string and $ matches the end of the input string. However, with RegexOptions.Multiline enabled, ^ also matches the start of each line within the input string and $ matches the end of each line. This option is particularly useful when dealing with multi-line input.

To use this option, include RegexOptions.Multiline as a parameter when creating your Regex object, which you can see in this example below! We’ll use this code to look for lines that start with a comment character denoted by the hashtag/pound symbol, #:

```csharp
using System;
using System.Text.RegularExpressions;

string multiLineText = 
    """
    This is some sample text.
    # This is a comment.
    And here's another line.
    # Another comment.
    """;

foreach (var comment in FindComments(multiLineText))
{
    Console.WriteLine(comment);
}

static string[] FindComments(string input)
{
	// Use RegexOptions.Multiline to treat ^ as the start of each line.
	Regex commentRegex = new Regex("^#.*$", RegexOptions.Multiline);

	var matches = commentRegex.Matches(input);
	string[] comments = new string[matches.Count];
	for (int i = 0; i < matches.Count; i++)
	{
		comments[i] = matches[i].Value;
	}

	return comments;
}
```

If you want to play around with [this example right in your browser, check out this DotNetFiddle](https://dotnetfiddle.net/e4X9ZP):

{% embed https://dotnetfiddle.net/e4X9ZP %}

---

## **Wrapping Up Regex Options in CSharp**

In this article, I gave you a brief rundown of some simple methods that we have access to in C# for working with regular expressions. But beyond that, we got to see a handful of different regex options in C# that we have access to that can change the behavior of our matching!

Try out the code examples! Play around with them in DotNetFiddle! Consider benchmarking your code with BenchmarkDotNet if you’re looking to tune the performance of your pattern matching using regular expressions in C#.

If you found this useful and you’re looking for more learning opportunities, consider [subscribing to my free weekly software engineering newsletter](https://subscribe.devleader.ca/) and check out my [free videos on YouTube](https://www.youtube.com/@devleader?sub_confirmation=1)! Meet other like-minded software engineers and [join my Discord community](https://www.devleader.ca/discord-community-access/)!

{% embed https://weekly.devleader.ca/embed %} 

---

## **Want More Dev Leader Content?**

* Follow along on this platform if you haven’t already!    
* Subscribe to my free weekly software engineering and dotnet-focused newsletter. I include exclusive articles and early access to videos:  
    [**SUBSCRIBE FOR FREE**](https://subscribe.devleader.ca/)    
* Looking for courses? Check out my offerings:  
    [**VIEW COURSES**](https://devleader.ca/courses)    
* E-Books & other resources:  
    [**VIEW RESOURCES**](https://products.devleader.ca/)    
* Watch hundreds of full-length videos on my YouTube channel:  
    [**VISIT CHANNEL**](https://youtube.com/@devleader?sub_confirmation=1)    
* Visit my website for hundreds of articles on various software engineering topics (including code snippets):  
    [**VISIT WEBSITE**](https://devleader.ca/)    
* Check out the repository with many code examples from my articles and videos on GitHub:  
    [**VIEW REPOSITORY**](https://github.com/ncosentino/DevLeader)