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

Adding More Static Methods

Sina Iravanian

3: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

3: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

5: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

7: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

3: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

1: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

7: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

0:18 2 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

23: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

16: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

16: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

14: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

22: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

23: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

6: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

8: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

14: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

6:10 10 Mar '07

That is all.
Sign In·View Thread·Permalink

Re: NICE

reinux

13: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

7: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

20: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

12: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

2: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, @"\\\\\\\\", @"\\");

This preserves all \*, \? and \\ occurences

A small improvement?

Jim Parsells

11:40 16 Sep '05

You may wish to consider adding "$" to the end of the Regex to get behavior that fully matches normal wildcard searching (maybe ^ at the beginning as well).
As presented: A pattern of "*.dll" will find files named "abc.dll.tmp" for example. Hmmmm ... I wonder why have files of that form in my WINNT\System32 directory...TBD.
Otherwise, a neat trick. I'd like to see more short, useful, items on CodeProject.

Re: A small improvement?

Jim Parsells

17:35 16 Sep '05

Inquiring minds might like to know that performing the equivalent file name pattern matching using the VB.Net Like operator does the same match in 60 per cent of the time. Regexs are very powerful, but not without a cost.
I assumed that there was a cost to using Regex for simple matches so I got inspired to try it out. Do each over 2700 file names (about 1300 matches) 100 times, throw out the top & bottom 10 scores -- Like wins by 40 per cent.
Average times: Ignoring case in both, compiling the Regex on initiation of
wildcard class.
Like =.0083 seconds
Regex=.0132 seconds
Either one gets over 2700 comparisons very quickly.

Jim Parsells