How to Access Named Capturing Groups in a .Net Regex

const regex = /^(.*?)([\s:]+)?{([\s\S].*)?.$/gm;const str = `key:{value}key:{valu{0}e}key:{valu{0}e}key:   {val-u{0}e}key:  {val__[!]-u{0}{1}e}`;const subst = `$1,$3`;
// The substituted value will be contained in the result variableconst result = str.replace(regex, subst);
console.log('Substitution result: ', result);

Trying to get multiple RegEx matches with named groups in C#

You need to iterate through all the matches of the string. Regex.Match will only return the first match.

public static string[] ValidatePattern(string pattern, string input, List<string> groupNames)
{
    Regex regex = new Regex(pattern);
    var matches = regex.Matches(input);

    List<string> results = new List<string>();
    foreach (Match match in matches) {
        foreach (var name in groupNames)
        {
            var group = match.Groups[name];
            results.Add(group.Success ? group.Value : string.Empty);
        }
    }
    return results.ToArray();
}

Named capturing group to different names

You can nest the named capturing groups and use

^(?<someName>[^ ]*) (?<someNewFancyNae>(?<someNameWeWishToDeprecate>[^ ]*))$

Or,

^(?<someName>\S+)\s+(?<someNewFancyNae>(?<someNameWeWishToDeprecate>\S+))$

See the regex demo.

How do I make Regex capture only named groups

You always have group 0: that's the entire match. Numbered groups are relative to 1 based on the ordinal position of the opening parenthesis that defines the group. Your regular expression (formatted for clarity):

(?<code>
  ^
  (?<l1> [\d]{2} )
  /
  (?<l2> [\d]{3} )
  /
  (?<l3> [\d]{2} )
  $
|
  ^
  (?<l1>[\d]{2})
  /
  (?<l2>[\d]{3})
  $
|
   (?<l1> ^[\d]{2} $ )
)

Your expression will backtrack, so you might consider simplifying your regular expression. This is probably clearer and more efficient:

static Regex rxCode = new Regex(@"
  ^                    # match start-of-line, followed by
  (?<code>             # a mandatory group ('code'), consisting of
    (?<g1> \d\d )      # - 2 decimal digits ('g1'), followed by
    (                  # - an optional group, consisting of
      /                #   - a literal '/', followed by
      (?<g2> \d\d\d )  #   - 3 decimal digits ('g2'), followed by
      (                #   - an optional group, consisting of
        /              #     - a literal '/', followed by
        (?<g3> \d\d )  #     - 2 decimal digits ('g3')
      )?               #     - END: optional group
    )?                 #   - END: optional group
  )                    # - END: named group ('code'), followed by
  $                    # - end-of-line
" , RegexOptions.IgnorePatternWhitespace|RegexOptions.ExplicitCapture );

Once you have that, something like this:

string[] texts = { "12" , "12/345" , "12/345/67" , } ;

foreach ( string text in texts )
{
  Match m = rxCode.Match( text ) ;
  Console.WriteLine("{0}: match was {1}" , text , m.Success ? "successful" : "NOT successful" ) ;
  if ( m.Success )
  {
    Console.WriteLine( "  code: {0}" , m.Groups["code"].Value ) ;
    Console.WriteLine( "  g1: {0}" , m.Groups["g1"].Value ) ;
    Console.WriteLine( "  g2: {0}" , m.Groups["g2"].Value ) ;
    Console.WriteLine( "  g3: {0}" , m.Groups["g3"].Value ) ;
  }
}

produces the expected

12: match was successful
  code: 12
  g1: 12
  g2:
  g3:
12/345: match was successful
  code: 12/345
  g1: 12
  g2: 345
  g3:
12/345/67: match was successful
  code: 12/345/67
  g1: 12
  g2: 345
  g3: 67

.net regex optional named groups

You can match subparts using [^/]+ pattern (any 1+ chars other than / char) and make the numbered capturing group rather than the value named capturing group optional, i.e. (/(?<value>.+)?) => (?:/(?<value>.+))? (also, you may turn the capturing group into non-capturing, or use (?n) inline ExplicitCapture modifier to make all capturing groups behave as non-capturing).

You may use

^client/(?<id>[^/]+)/box/(?<type>[^/]+)(?:/(?<value>[^/]+))?

See the regex demo

How do I get the name of captured groups in a C# Regex?

Use GetGroupNames to get the list of groups in an expression and then iterate over those, using the names as keys into the groups collection.

For example,

GroupCollection groups = regex.Match(line).Groups;

foreach (string groupName in regex.GetGroupNames())
{
    Console.WriteLine(
       "Group: {0}, Value: {1}",
       groupName,
       groups[groupName].Value);
}

---

Related Topics