Regular expression to select repeating groups

Question

I have a series of grouped values that follow a specific format and would like to use a single expression to capture them into groups. For example, I have -group1 -group2 -group3 and am trying to use something similar to (-[\s\S]{1,}?) This is basically allowing me to capture the entire string into a single group but I'd like to be able to backreference each of the values separately. I figured the ? would force it to be non-greedy and, therefore, split the pattern match into three separate groups (for example). For now I am simply repeating the reference (-[\s\S]*?) but it seems there should be a more elegant expression.
Thanks!

Answer 1

You are in luck because C# is one of the few languages (if not the only one) that supports subexpression captures

https://msdn.microsoft.com/en-us/library/system.text.regularexpressions.capture(v=vs.110)

The .NET API can be looked at as follows

 Matches
     Groups (most regex engines stop here)
         Captures (unique for .NET)

It's not clear from your question what you want to match exactly but this should get you started. Ask again if you are stuck.

  string input = "-group1 -group2 ";
  string pattern = @"(-\S*\W){2}";
  foreach (Match match in Regex.Matches(input, pattern))
  {
     Console.WriteLine("Match: {0}", match.Value);
     for (int groupCtr = 0; groupCtr < match.Groups.Count; groupCtr++)
     {
        Group group = match.Groups[groupCtr];
        Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
        for (int captureCtr = 0; captureCtr < group.Captures.Count; captureCtr++)
           Console.WriteLine("      Capture {0}: {1}", captureCtr, 
                             group.Captures[captureCtr].Value);
     }                      
  } 

This ouputs

Match: -group1 -group2 
   Group 0: -group1 -group2 
      Capture 0: -group1 -group2 
   Group 1: -group2 
      Capture 0: -group1 
      Capture 1: -group2 

As you can see (Group 1, Capture 0) and (Group 1, Capture 1) offer the individual captures of a group (and not the last as in most languages)

This address I think of what you describe as "to be able to backreference each of the values separately"

(You use the term backreference but I don't think you are aiming for a replacement pattern right?)