If you’re a beginner software developer then you may have already heard about regular expressions, but you might not have been able to put them into practice yet. No fear! In this article, I’ll walk you through 3 very simple examples of regular expressions in C# to get you started with using them. No — I won’t be doing a deep dive into complex patterns and super wild and fancy things that you can do with regular expressions. Nope. Just some simple C# examples to get you pointed in the right direction! 1 – Regex Starts With When working with regular expressions in C#, you can easily match strings that start with a specific pattern. This can be useful in scenarios where you need to find or extract strings that have a particular prefix. And yeah — I know you’re probably thinking “Hey Nick, don’t we already have to use?” — and you’re right! But you can’t use that to match patterns more complex than a string directly. string.StartsWith To pattern match at the beginning of a string, you’ll need to use the caret (^) symbol as an anchor in your regular expression pattern. The caret symbol represents the start of a line or string in regular expressions, so by placing it at the beginning of your pattern, you ensure that the match you are looking for occurs at the start of the string. To demonstrate this, consider the following code example: using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

List<string> inputs = new()
{
    "Hello, World!",
    "Something something Hello!",
    "  Hello",
    "Hello from Dev Leader!",
};

string pattern = "^Hello";
Regex regex = new Regex(pattern);

foreach (var input in inputs)
{
    Match match = regex.Match(input);
    Console.WriteLine(
        $"'{input}' {(match.Success ? "did" : "did not")} " +
        "match the string starting with the pattern.");
} In this example, I’ve created a list of input strings that we can exercise our regular expression against. We’ll use a caret at the beginning of the pattern, which otherwise just says “Hello”, so effectively we’re looking for strings that start with Hello. You can . try it out directly in your browser with this DotNetFiddle Now a question you *should* be asking yourself is… is this a good example of using a regular expression instead of string.StartsWith? What do you think the performance of this might be like? Try comparing them in BenchmarkDotNet to find out! 2 – Regex Ends With If you read the previous section: We’re talking about going the other way now. If you didn’t read the previous section: Go read that and then come back and read the first sentence in this section. Choose your own adventure! And now we can discuss how to match the end of a string with our regex pattern. To match patterns that end with a particular string, we can use the dollar sign ($) symbol as an anchor in our regular expression pattern. The dollar sign represents the end of the string, ensuring that the specified pattern is only matched if it occurs at the end. The opposite of what we saw with the caret symbol. Let’s consider an example where we want to find all the words in a given text that end with the suffix “ing”. We can achieve this using regular expressions in C# with the following code snippet: using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

List<string> inputs = new()
{
    "Coding", // match
    "I love programming!", // no match
    "Coding is fun!", // no match
    "I love programming", // match
};

string pattern = "ing$";
Regex regex = new Regex(pattern);

foreach (var input in inputs)
{
    Match match = regex.Match(input);
    Console.WriteLine(
        $"'{input}' {(match.Success ? "did" : "did not")} " +
        "match the string ending with the pattern.");
} Take note of the input strings above because all of them contain “ing” but not all of them end with “ing”. Which ones will match? If you want to try . the Regex ends with an example in your browser, check out this DotNetFiddle 3 – Regex Is Match While we’ve been looking at comparisons to other string methods like StartsWith and EndsWith, we can continue this comparison with regex in C#. We know that regex will allow us to do more complex pattern matching compared to these string method variations, so what if we simply want to know if there’s a pattern match? If you wanted something similar to just to know if a pattern matches a string, we can use the method to perform the pattern matching. string.Contains Regex.IsMatch() Note that will simply return a boolean result instead of a type. If you want more information about when your match succeeds, much like in the earlier examples, then you can just use the method or even the to get all matching instances within the source string. I wanted to spice it up a bit and use this example just to compare to , but if you wanted to compare it to something closer to to find the position, switch back to the other methods. Regex.IsMatch() Match Match Matches string.Contains string.IndexOf If we don’t care about beginning or ending matching, we can ditch the ^ and $ symbols in our regular expressions. Let’s check out this code example that has a slightly more advanced pattern to match: using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

List<string> inputs = new()
{
    "Nick", // no match
    "Nick1", // no match
    "1Nick", // no match
    "Nick42", // match
    "42Nick", // match
    "4Nick2", // match
    "42", // match
    "1337", // match
    "6", // no match
};

string pattern = "[0-9]+[a-zA-Z]*[0-9]+";
Regex regex = new Regex(pattern);

foreach (var input in inputs)
{
    bool isMatch = regex.IsMatch(input);
    Console.WriteLine(
        $"'{input}' {(isMatch ? "did" : "did not")} " +
        "match the pattern.");
} In this example, the method takes in the variable and the variable was provided to the instance at creation time. If you examine the pattern that we’re trying to match, we need to have at least 2 numbers with either 0 or many characters from a to z (case not being considered). But what about if we had 2 numbers that were separated by a character that wasn’t in the English alphabet? . Regex.IsMatch() input pattern Regex Try it out for yourself with this DotNetFiddle Wrapping Up Regular Expressions in C# As you can see from these examples, regular expressions in C# aren’t so scary, right? They’re just a little bit more complicated than doing some other string operations. At least, on the surface. There are regex options in C# to explore and, of course, the regular expressions that we write can get incredibly complex. Regular expressions can be a powerful tool for us to use, but keep in mind that you’ll want to balance things out. Consider readability, performance, and other characteristics if you start heavily relying on regular expressions for matching patterns in your applications! If you found this useful and you’re looking for more learning opportunities, consider and check out my ! subscribing to my free weekly software engineering newsletter free videos on YouTube

This story contains new, firsthand information uncovered by the writer.

This story contains AI-generated text. The author has used AI either for research, to generate outlines, or write the text itself. 

3 Examples of Regular Expressions in C# For Beginners

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

3 Beginner Tips You Need to Know for async await in C#

111 Stories To Learn About Csharp

130 Stories To Learn About Dotnet

C# 8.0 Indices and Ranges

3 Insanely Easy Changes You Can Make To Clean Up Your Code

3 Beginner Tips You Need to Know for async await in C#

111 Stories To Learn About Csharp

130 Stories To Learn About Dotnet

C# 8.0 Indices and Ranges

3 Insanely Easy Changes You Can Make To Clean Up Your Code

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps