Common Patterns Library

CommonPatterns is a static class of ready-made patterns for formats that show up in almost every application: email addresses, URLs, IP addresses, dates, card numbers, versions, tokens and numbers. Each method returns an ordinary Pattern, so you can test it, extract from it, combine it with rules, or chain more settings onto it, exactly like a pattern you built yourself.

Use this page when you need to:

validate a common format without writing the regex yourself,
pick how strictly an email address or URL is checked,
read parts of a value, such as the components of a version or a date,
make \d accept only the ASCII digits 0-9,
know exactly what each pattern accepts and rejects before you rely on it.

All members on this page live in the Masterly.FluentRegex namespace and work on every target the package supports: .NET Standard 2.1, .NET 8 and .NET 10.

Using a common pattern

Call a method and use the pattern it returns. ToString() shows the regex, so you can always check what you are getting.

using System;
using Masterly.FluentRegex;

Pattern email = CommonPatterns.Email();

Console.WriteLine(email.IsMatch("user@example.com"));   // True
Console.WriteLine(email.IsMatch("invalid"));            // False
Console.WriteLine(email);                               // ^[a-zA-Z\d\._\-]+@[a-zA-Z\d\.\-]+\.[a-zA-Z]{2,}$

Almost every pattern is wrapped in ^ and $, so it validates a whole value. The two exceptions are HtmlTag() and MarkdownLink(), which are written to find values inside text.
Every call builds a new Pattern. Store it in a field or a static readonly member when you use it often. The pattern caches its compiled Regex after the first match.
Patterns are immutable. Chaining a setting returns a new pattern and leaves the original unchanged (see Customizing a common pattern).
Every method also has an overload that takes a DigitMode. By default \d matches any Unicode decimal digit; pass DigitMode.Ascii to accept only 0-9 (see Unicode or ASCII digits).

warning

In .NET, $ matches at the very end of the input and also just before a final newline. IsMatch therefore accepts a value that ends with \n:

Pattern zip = CommonPatterns.ZipCode();

Console.WriteLine(zip.IsMatch("12345"));     // True
Console.WriteLine(zip.IsMatch("12345\n"));   // True: $ also matches before a final newline

Trim input from forms and files first, or validate with IsValid on a constrained pattern, which requires the match to cover the whole input (see Adding checks a regex cannot express).

Customizing a common pattern

A common pattern is a normal Pattern, so every pattern setting works on it. Use WithOptions to change how the regex runs and WithTimeout to limit how long one match may take.

using System;
using System.Text.RegularExpressions;
using Masterly.FluentRegex;

Pattern url = CommonPatterns.Url().WithOptions(RegexOptions.IgnoreCase);
Console.WriteLine(url.IsMatch("HTTPS://Example.com"));   // True

Pattern guid = CommonPatterns.Guid().WithTimeout(TimeSpan.FromMilliseconds(100));
Console.WriteLine(guid.Timeout);                // 00:00:00.1000000

Console.WriteLine(ReferenceEquals(CommonPatterns.Email(), CommonPatterns.Email()));   // False

Url() expects a lowercase http or https scheme. RegexOptions.IgnoreCase accepts any case.
The last line shows that each call creates a new instance.
To build a stricter or looser variant, start from the regex shown by ToString() with Pattern.FromRegex, or write your own with the fluent API (see Composing Patterns).