Converting Wildcards to Regexes

Introduction

Ever wondered how to do wildcards in .NET? It's not hard, all you have to do is use regular expressions. But it's not always easy to figure it out either. I found that I had to dig around for a while to figure out how to do it properly.

Even though regexes are a lot more powerful, wildcards are still good in situations where you can't expect the user to know or learn the cryptic syntax of regexes. The most obvious example is in the file search functionality of practically all OSs -- there aren't many that don't accept wildcards. I personally need wildcards to handle the HttpHandlers tag in web.config files.

Note: This method is good enough for most uses, but if you need every ounce of performance with wildcards, here is a good place to start.

Using the Code

There are three steps to converting a wildcard to a regex:

Escape the pattern to make it regex-safe. Wildcards use only * and ?, so the rest of the text has to be converted to literals.
Once escaped, * becomes \* and ? becomes \?, so we have to convert \* and \? to their respective regex equivalents, .* and ..
Prepend ^ and append $ to specify the beginning and end of the pattern.

So, here's the golden function:

public static string WildcardToRegex(string pattern)
{
  return "^" + Regex.Escape(pattern).
  Replace("\\*", ".*").
  Replace("\\?", ".") + "$";
}

Just to make it look cool, I wrapped it in a Wildcard class that inherits Regex.

/// <summary>
/// Represents a wildcard running on the
/// <see cref="System.Text.RegularExpressions"/> engine.
/// </summary>
public class Wildcard : Regex
{
 /// <summary>
 /// Initializes a wildcard with the given search pattern.
 /// </summary>
 /// <param name="pattern">The wildcard pattern to match.</param>
 public Wildcard(string pattern)
  : base(WildcardToRegex(pattern))
 {
 }
 
 /// <summary>
 /// Initializes a wildcard with the given search pattern and options.
 /// </summary>
 /// <param name="pattern">The wildcard pattern to match.</param>
 /// <param name="options">A combination of one or more
 /// <see cref="System.Text.RegexOptions"/>.</param>
 public Wildcard(string pattern, RegexOptions options)
  : base(WildcardToRegex(pattern), options)
 {
 }
 
 /// <summary>
 /// Converts a wildcard to a regex.
 /// </summary>
 /// <param name="pattern">The wildcard pattern to convert.</param>
 /// <returns>A regex equivalent of the given wildcard.</returns>
 public static string WildcardToRegex(string pattern)
 {
  return "^" + Regex.Escape(pattern).
   Replace("\\*", ".*").
   Replace("\\?", ".") + "$";
 }
}

You can use it like any other Regex -- case-(in)sensitivity, string replacement, matching and all.

// Get a list of files in the My Documents folder
string[] files = System.IO.Directory.GetFiles(
 System.Environment.GetFolderPath(
 Environment.SpecialFolder.Personal));

// Create a new wildcard to search for all
// .txt files, regardless of case
Wildcard wildcard = new Wildcard("*.txt", RegexOptions.IgnoreCase);

// Print all matching files
foreach(string file in files)
 if(wildcard.IsMatch(file))
  Console.WriteLine(file);

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

About the Author

reinux

Canada

Member

The cows are here to take me home now...

Article Top

Poor

Excellent

Add a reason or comment to your vote: x
Votes of 3 or less require a comment

Comments and Discussions

You must Sign In to use this message board. (secure sign-in)

Search this forum
	Profile popups Noise Layout Per page

Word wild card matching behavior a little different from this [modified]

weciii

5:21 2 Mar '12

Test string:
"she sells sea shells by the sea shore"

Wild card find pattern to type in:
"s*a"

To find in Word:
Open Word 2010 and paste the text.
On the home tab in the far right, select the find drop down and select advanced find. In the resulting dialog type "s*a". Click the more button and check use wildcards. Click find next. It will find "she sells sea" as the first match.

The regex pattern generated for s*a is "^s.*a$"

If you test that regex pattern, it comes back with 0 matches.

The current regex pattern looks like it will only get a match when 's' is at the beginning of the string or line and 'a' is at the end of the string or line.
I'm not too good with regex and could use a solution that would find the pattern anywhere in the string. I've tried a few modifications to the existing regex pattern, but desired result not reached yet.

****Update****
Found what I was looking for.
Changing the code to the following did the trick:

        
        public static string WildcardToRegex(string pattern)
        {
            return //"^" + 
                Regex.Escape(pattern).
             Replace("\\*", ".*?").
             Replace("\\?", ".");// +"$";
        }

Removed '^', and '$' which says matches need to be at beginning and end of string or line. Changed ".*" to ".*?" - turned 'greedy quantifier' into 'lazy quantifier'. After that, it will still come back with only 2 matches. To compensate for that you could search the string multiple times bumping the start point of the search each time like below:

            Wildcard w = new Wildcard("s*a", RegexOptions.CultureInvariant);
 
            string s = "she sells sea shells by the sea shore";
            int length = s.Length;
            int index = 0;
 
            Match m = w.Match(s);
            StringBuilder sb = new StringBuilder();
 
            bool bsuccess = m.Success;
            while (bsuccess)
            {
                sb.AppendLine(m.Value);
                index = s.IndexOf(m.Value, index) + 1;
                if (index < length)
                {
                    m = w.Match(s, index);
                    bsuccess = m.Success;
                }
                else
                    bsuccess = false;
            }

which gives 7 results like Word does:
she sells sea
sells sea
s sea
sea
shells by the sea
s by the sea
sea

modified 5 Mar '12.

My vote of 5

vet0n

21:46 23 Feb '12

Great article! Would be nice to see some tricky unit-tests for this as well.
Sign In·View Thread·Permalink

Adding More Static Methods

Sina Iravanian

2:21 14 Dec '11

Hi,

Thanks for the code. I liked it, especially the fact that it was derived from Regex. I use Regex static methods a lot, and hence added these methods to your Wildcard class so that its interface matches more the .NET's Regex class. Here are these methods:

public static Match Match(string input, string pattern, RegexOptions options)
{
    string wildcardPattern = WildcardToRegex(pattern);
    return Regex.Match(input, wildcardPattern, options);
}
 
public static Match Match(string input, string pattern)
{
    return Match(input, pattern, RegexOptions.None);
}
 
public static bool IsMatch(string input, string pattern, RegexOptions options)
{
    string wildcardPattern = WildcardToRegex(pattern);
    return Regex.IsMatch(input, wildcardPattern, options);
}
 
public static bool IsMatch(string input, string pattern)
{
    return IsMatch(input, pattern, RegexOptions.None);
}
 
public static MatchCollection Matches(string input, string pattern, RegexOptions options)
{
    string wildcardPattern = WildcardToRegex(pattern);
    return Regex.Matches(input, wildcardPattern, options);
}
 
public static MatchCollection Matches(string input, string pattern)
{
    return Regex.Matches(input, pattern, RegexOptions.None);
}

My vote of 5

Nagy Vilmos

2:24 8 Nov '10

The method `WildcardToRegex` has just saved me from having to write a very messy search class. TVM.
Sign In·View Thread·Permalink

bug?? with '.'

alchemy9

4:07 16 Nov '09

. is any character in the regular expression on and wildcard search it should still be a '.'. I would suggest replacing . with \x2E in the regular expression. Ian
Sign In·View Thread·Permalink

Re: bug?? with '.'

Steve Kutnar

6:28 2 Sep '10

Did you see the latest code? It uses Regex.Escape to handle this. http://www.codeproject.com/Messages/1423024/Re-Doesnt-work-with-input-string-containing-meta-c.aspx[^]
Sign In·View Thread·Permalink

How to add other chars - [A-Z] [modified]

boopathi_tpgit

2:22 20 Oct '09

It is a nice article. I need to add character specification or limitation [a-z] or [1-9] pattern like that.. is it possible? Advance Thanks Boopathi.S modified on Wednesday, October 21, 2009 10:09 AM
Sign In·View Thread·Permalink	1.00/5 (1 vote)

Difference between httphandlers and httpmodules

gaurav2007

0:20 20 Jun '08

Hi Devlopers, Could u tell me the exact difference between http handlers and http modules except their position in pipeline processing Thanks GK
Sign In·View Thread·Permalink	1.00/5 (2 votes)

Re: Difference between httphandlers and httpmodules

reinux

6:24 20 Jun '08

I'm not too sure. You'd probably get a better answer on the ASP.NET forums[^].
Sign In·View Thread·Permalink

There's a new version of the RegEx Tester Tool !

BucanerO_Slacker

23:18 1 Mar '08

I have released a new version of the RegEx Tester tool. You can download it free from http://www.codeproject.com/KB/string/regextester.aspx and http://sourceforge.net/projects/regextester

With RegEx Tester you can fully develop and test your regular expression against a target text. It's UI is designed to aid you in the RegEx developing. It uses and supports ALL of the features available in the .NET RegEx Class.

Small suggestion

Davide Icardi

22:12 16 Dec '07

Thanks for the useful article!

Below a little patch where I have added the matchType parameter to allow more options when adding the ^ or $ characters (see WildcardMatch enum):

    /// <summary>
    /// Represents a wildcard running on the
    /// <see cref="System.Text.RegularExpressions" /> engine.
    /// </summary>
    public class Wildcard : Regex
    {
        /// <summary>
        /// Initializes a wildcard with the given search pattern.
        /// </summary>
        /// <param name="pattern">The wildcard pattern to match.</param>
        public Wildcard(string pattern, WildcardMatch matchType)
            : base(WildcardToRegex(pattern, matchType))
        {
        }
 
        /// <summary>
        /// Initializes a wildcard with the given search pattern and options.
        /// </summary>
        /// <param name="pattern">The wildcard pattern to match.</param>
        /// <param name="options">A combination of one or more
        /// <see cref="System.Text.RegexOptions" />.</param>
        public Wildcard(string pattern, RegexOptions options, WildcardMatch matchType)
            : base(WildcardToRegex(pattern, matchType), options)
        {
        }
 
        /// <summary>
        /// Converts a wildcard to a regex.
        /// </summary>
        /// <param name="pattern">The wildcard pattern to convert.</param>
        /// <returns>A regex equivalent of the given wildcard.</returns>
        public static string WildcardToRegex(string pattern, WildcardMatch matchType)
        {
            string escapedPattern = Regex.Escape(pattern);
            escapedPattern = escapedPattern.Replace("\\*", ".*");
            escapedPattern = escapedPattern.Replace("\\?", ".");
 
            if (matchType == WildcardMatch.Anywhere)
                return escapedPattern;
            else if (matchType == WildcardMatch.EndsWith)
                return escapedPattern + "$";
            else if (matchType == WildcardMatch.StartsWith)
                return "^" + escapedPattern;
            else if (matchType == WildcardMatch.Exact)
                return "^" + escapedPattern + "$";
            else
                throw new ArgumentOutOfRangeException("matchType");
        }
    }
 
    public enum WildcardMatch
    {
        Exact = 0,
        Anywhere = 1,
        StartsWith = 2,
        EndsWith = 3
    }

Davide

Re: Small suggestion

philippe dykmans

15:39 31 May '08

Correct me if i'm wrong, but according the syntax of wildcards as i know them: = Exact * = StartsWith * = EndsWith ** = Anywhere So, what's the use of adding the "WildcardMatch matchType" ? Philippe Dykmans Software developpement Advanced Bionics Corp.
Sign In·View Thread·Permalink

Correction...

philippe dykmans

15:45 31 May '08

Sorry. The html parser screwed up my first message because i used the wrong brackets. I meant to say that according wildcard syntax: pattern = Exact pattern = EndsWith pattern = StartsWith pattern = Exact And therefore i don't see the need for adding the WildcardMatch enum. Philippe Dykmans Software developpement Advanced Bionics Corp.
Sign In·View Thread·Permalink

Re: Correction...

Davide Icardi

13:19 1 Jun '08

I think that with some reg expressions is better because you can declare exactly your intentions.
For example sometime I want to check if the pattern match the whole text, so in this case you can use Exact. (*pattern* is not the same as Exact, in this case I force that the pattern match from start to end adding ^ and $).
But probably you are right for the StartsWith and EndsWith, they are not very useful.

Davide

Re: Small suggestion

sssw28

21:25 5 Mar '11

Davide, Thanks for posting your enhancement. It's exactly what I needed for my application! Tim
Sign In·View Thread·Permalink

Simple, yet good

norm .net

22:33 16 May '07

Good solution. .net is a box of never ending treasures, every day I get find another gem.
Sign In·View Thread·Permalink

Re: Simple, yet good

reinux

5:32 17 May '07

Be sure to check out the more robust version[^] too.
Sign In·View Thread·Permalink

Just what I was looking for.

Ryan McFarren

7:55 12 Apr '07

The searchPattern parameter for GetFiles and GetDirectories sucks eggs. This was just what I needed, thanks. Ryan http://chicknet.blogspot.com/
Sign In·View Thread·Permalink

Re: Just what I was looking for.

reinux

13:24 12 Apr '07

Be sure you looked at the updated code in my comment here: http://www.codeproject.com/csharp/wildcardtoregex.asp?msg=1423024#xx1423024xx[^]
Sign In·View Thread·Permalink

NICE

Ben Allfree

5:10 10 Mar '07

That is all.
Sign In·View Thread·Permalink

Re: NICE

reinux

12:24 10 Mar '07

I hope you saw this[^] code right? I haven't gotten around to fixing the article... hahaha.
Sign In·View Thread·Permalink

Doesnt work with input string containing meta characters

skk-ws

6:41 31 Jan '06

Lets say the input string is abcdef. The wildcard pattern I want to use is a\d. I want to match abcd. The current code gives incorrect results. Can you suggest a way to make it work if the input string contains meta characters? Thanks SK SK
Sign In·View Thread·Permalink	5.00/5 (1 vote)

Re: Doesnt work with input string containing meta characters

reinux

19:03 1 Feb '06

Hmm... this is getting more complicated than I thought I'll have to look at it a bit more closely over the weekend.
Sign In·View Thread·Permalink

Re: Doesnt work with input string containing meta characters

reinux

11:22 26 Mar '06

Well, I finally took a look at it. The whole idea of just replacing strings doesn't work; the string needs to be parsed properly.

I don't have time to update the article at the moment. In the meantime, here's the new code. Maybe it's still useful.

private static string WildcardToRegex(string wildcard)
{
	StringBuilder sb = new StringBuilder(wildcard.Length + 8);
 
	sb.Append("^");
 
	for (int i = 0; i < wildcard.Length; i++)
	{
		char c = wildcard[i];
		switch(c)
		{
			case '*':
				sb.Append(".*");
				break;
			case '?':
				sb.Append(".");
				break;
			case '\\':
				if (i < wildcard.Length - 1)
					sb.Append(Regex.Escape(wildcard[++i].ToString()));
				break;
			default:
				sb.Append(Regex.Escape(wildcard[i].ToString()));
				break;
		}
	}
 
	sb.Append("$");
 
	return sb.ToString();
}

Re: Doesnt work with input string containing meta characters

N3croman

1:13 12 Jan '11

Fixed using more precise replacing:

string s = "^" + Regex.Escape(pattern) + "$"; 
s = Regex.Replace(s, @"(?<!\\)\\\*", @".*"); // Negative Lookbehind
s = Regex.Replace(s, @"\\\\\\\*", @"\*"); 
s = Regex.Replace(s, @"(?<!\\)\\\?", @".");  // Negative Lookbehind
s = Regex.Replace(s, @"\\\\\\\?", @"\?"); 
return Regex.Replace(s, @"\\\\\\\\", @"\\");