Mastering Regular Expression. Part 8: Testing and Debugging Regex in C#

Why This Matters

Writing regex is one thing — making sure it's correct, fast, and maintainable is another.

In this part, you’ll learn:

1. How to test regex patterns in Visual Studio
2. How to debug regex with online tools
3. How to write unit tests for regex
4. How to benchmark regex performance
5. How to use .NET libraries for regex diagnostics
6. How to build a live regex tester inside your own app

---

8.1 Testing Regex in Visual Studio

✅ Steps:

1. Open any .cs file.
2. Write a regex as a string:

var pattern = @"\d{4}-\d{2}-\d{2}";

3. Hover over it → Visual Studio (2022+) shows a preview.
4. Use Quick Actions > Test Regex to open the test window.

✨ Features:

• Test input against the pattern.
• Toggle multiline, ignore case, etc.
• See groups and matches live.

---

8.2 Online Regex Testers

🔧 Regex101.com

• Supports flavor selection (choose ".NET")
• Highlights all matches & groups
• Provides full explanation, debug mode, and code generation
• You can share regex links

🧪 Example:

Pattern: (?<date>\d{4}-\d{2}-\d{2})
Test string: "Today is 2025-08-04"

---

🔧 RegexStorm.net

Built specifically for .NET. Best for C# developers.

• Test .NET patterns
• Shows MatchCollection
• Supports RegexOptions flags
• Fast and accurate

---

8.3 Unit Testing Regex in C#

You can (and should) write unit tests for regex to catch edge cases.

✔ NUnit Example:

[TestFixture]
public class RegexTests {
    [Test]
    public void Match_ISODate_ShouldPass() {
        var input = "2025-08-04";
        var pattern = @"^\d{4}-\d{2}-\d{2}$";

        Assert.IsTrue(Regex.IsMatch(input, pattern));
    }

    [Test]
    public void Match_InvalidDate_ShouldFail() {
        var input = "Aug 4, 2025";
        var pattern = @"^\d{4}-\d{2}-\d{2}$";

        Assert.IsFalse(Regex.IsMatch(input, pattern));
    }
}

You can use xUnit or MSTest similarly.

---

8.4 Debug Complex Patterns with Explanation Tools

Use Regex101 or regexr.com to get live breakdowns of patterns.

Example pattern:

^(?<area>\(\d{3}\)|\d{3}-)?(?<prefix>\d{3})-(?<line>\d{4})$

Explanation tools will break this down into:

• Named groups
• Optional patterns
• Alternations
• Quantifiers

---

8.5 Catch Regex Bugs with Try-Catch

Some bad patterns will crash your app if unhandled.

🔐 Always validate before applying user-supplied regex:

try {
    var regex = new Regex(userPattern);
} catch (ArgumentException ex) {
    Console.WriteLine("Invalid regex: " + ex.Message);
}

---

8.6 Benchmark Regex Performance

Regex can be slow for very large data or bad backtracking patterns.

Use BenchmarkDotNet to test performance.

Example:

[MemoryDiagnoser]
public class RegexPerf {
    private string input = new string('a', 1000) + "!";
    private Regex safe = new Regex(@"^a{1000}!");
    private Regex catastrophic = new Regex(@"^(a+)+!");

    [Benchmark]
    public bool SafeRegex() => safe.IsMatch(input);

    [Benchmark]
    public bool CatastrophicBacktracking() => catastrophic.IsMatch(input);
}

⚠ Bad regex can be exponentially slow — benchmark if unsure.

---

8.7 Regex Diagnostic Tools in .NET

✔ RegexCompilationInfo

You can compile regex to assemblies:

var info = new RegexCompilationInfo(
    pattern: @"\d+",
    options: RegexOptions.Compiled,
    name: "DigitRegex",
    fullnamespace: "MyRegex",
    isPublic: true
);

Compiling makes heavy-use regexes 10–30% faster.

---

8.8 Build a Live Regex Tester in Your App

You can use TextBox, RichTextBox, or even Blazor to make a live regex UI.

Example (WPF snippet):

void OnTextChanged(object sender, EventArgs e) {
    var pattern = regexTextBox.Text;
    var input = inputTextBox.Text;

    try {
        var matches = Regex.Matches(input, pattern);
        resultTextBox.Text = string.Join("\n", matches.Cast<Match>().Select(m => m.Value));
    } catch {
        resultTextBox.Text = "Invalid regex";
    }
}

---

Bonus: Regex Cheat Sheet for C#

Pattern	Meaning
\d	Digit (0–9)
\D	Not digit
\w	Word character
\s	Whitespace
.	Any character (except newline)
*, +, ?	Repetition (0+, 1+, 0/1 times)
{n,m}	Between n and m repetitions
^, $	Start and end of line/string
[]	Character class
()	Capture group
(?:...)	Non-capturing group
(?<name>...)	Named group

---

Summary

You’ve learned how to:

• Test and debug regex patterns in Visual Studio and online tools
• Write unit tests for your expressions
• Benchmark and validate for performance
• Handle exceptions from user-supplied patterns
• Build regex tools into your app

---

Coming Up Next

In Part 9, we’ll dive into Common Mistakes and Anti-Patterns in regex, including:

• Catastrophic backtracking
• Overusing regex when simpler code is better
• Writing unreadable regex
• Too many capture groups
• Not escaping properly
• Input sanitation issues