How can I find the first regular expression that matches my input in the list of regular expressions?

Question

Is there any other way to write the following?

string input;

var match = Regex.Match(input, @"Type1");

if (!match.Success)
{
  match = Regex.Match(input, @"Type2");
}

if (!match.Success)
{
  match = Regex.Match(input, @"Type3");
}

Basically, I want to run my line through gammut expressions and see which one follows.

Answer 1

var patterns = new[] { "Type1", "Type2", "Type3" };
Match match;
foreach (string pattern in patterns)
{
    match = Regex.Match(input, pattern);
    if (match.Success)
        break;
}

or

var patterns = new[] { "Type1", "Type2", "Type3" };
var match = patterns
    .Select(p => Regex.Match(input, p))
    .FirstOrDefault(m => m.Success);

// In your original example, match will be the last match if all are
// unsuccessful. I expect this is an accident, but if you want this
// behavior, you can do this instead:
var match = patterns
    .Select(p => Regex.Match(input, p))
    .FirstOrDefault(m => m.Success)
    ?? Regex.Match(input, patterns[patterns.Length - 1]);

Since LINQ to Objects uses deferred execution, it Regex.Matchwill only be called until a match is found, so you don’t have to worry about this approach being too interesting.

Answer 2

Yes, I would write this in such a way as to avoid repeating the regular expression:

        match = Regex.Match(input, @"Type1|Type2|Type3");

        if (match.Success)
        {
            // loop, in case you are matching to multiple occurrences within the input.
            // However, Regex.Match(string, string) will only match to the first occurrence.
            foreach (Capture capture in match.Captures)
            {
                // if you care to determine which one (Type1, Type2, or Type3) each capture is
                switch (capture.Value)
                {
                    case "Type1":
                        // ...
                        break;
                    case "Type2":
                        // ...
                        break;
                    case "Type3":
                        // ...
                        break;
                }
            }
        }

---

Alternatively, if you have an arbitrary list of templates that you want to check:

        // assumption is that patterns contains a list of valid Regex expressions
        match = Regex.Match(input, string.Join("|", patterns));

        if (match.Success)
        {
            // obviously, only one of these return statements is needed

            // return the first occurrence
            return match.Captures[0].Value;

            // return an IEnumerable<string> of the matched patterns
            return match.Captures.OfType<Capture>().Select(capture => capture.Value);
        }

---

, . , , .

- "Pattern" , , :

EDIT: ,

        // assumption is that patterns contains a list of valid Regex expressions
        int i = 0;
        var mapOfGroupNameToPattern = patterns.ToDictionary(pattern => "Pattern" + (i++));

        match = Regex.Match(input, string.Join("|", mapOfGroupNameToPattern.Select(x => "(?<" + x.Key + ">" + x.Value + ")")));

        if (match.Success)
        {
            foreach (var pattern in mapOfGroupNameToPattern)
            {
                if (match.Groups[pattern.Key].Captures.Count > 0)
                {
                    // this is the pattern that was matched
                    return pattern.Value;
                }
            }
        }

Answer 3

Another way to do it. It iterates over the entire list, BUT you can look at a variable number or strings to match, without writing x numbers from if statements.

string input = "Type1";
List<string> stringsToTest = new List<string>() { @"Type1", @"Type2", @"Type3" };

var q = from string t in stringsToTest
        where Regex.IsMatch(input, t)
        select t;

//This way you can get how many strings on the list matched the input   
foreach(string s in q)
{
    Console.WriteLine(s);
}