Here is a simple example:

12345 /ABCDE123 /FGHIJ456 /KLMNO789

I would expect match.Groups to return 3 items:

• The first would be named "container" and contain a single Capture with a value of "12345".
• The second would be named "itemNumber" and contain three (3) items in its Captures collection: "ABCDE", "FGHIJ" and "KLMNO"
• The third would be named "quantity" and also contain three (3) items in its Captures collection: "123", "456" and "789"

This works when I use the explicit limiter, {3}, but only returns a single Capture for each group ("12345", "KLMNO" and "789") when I use a plus sign or asterisk for the repetition.

One other thing I noticed after testing further, it appears that everything works perfectly when the ".*/" - for the delimiter - is REMOVED!

Perhaps something like this:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            String example = "12345 /ABCDE123 /FGHIJ456 /KLMNO789";
            String pattern = @"(?<Container>\d{5})\s\/
                            (?<ItemNumber1>\w{5})(?<Quantity1>\d{3})\s\/
                            (?<ItemNumber2>\w{5})(?<Quantity2>\d{3})\s\/
                            (?<ItemNumber3>\w{5})(?<Quantity3>\d{3})";                            
            Regex rx = new Regex(pattern, RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
            Match m = rx.Match(example);
            if (m.Success)
            {
                Console.WriteLine("Container:    {0}", m.Groups["Container"].Value);
                Console.WriteLine("");
                Console.WriteLine("ItemNumber1:  {0}", m.Groups["ItemNumber1"].Value);                
                Console.WriteLine("Quantity1:    {0}", m.Groups["Quantity1"].Value);
                Console.WriteLine("");
                Console.WriteLine("ItemNumber2:  {0}", m.Groups["ItemNumber2"].Value);
                Console.WriteLine("Quantity2:    {0}", m.Groups["Quantity2"].Value);
                Console.WriteLine("");
                Console.WriteLine("ItemNumber3:  {0}", m.Groups["ItemNumber3"].Value);
                Console.WriteLine("Quantity3:    {0}", m.Groups["Quantity3"].Value);
            }
            Console.ReadLine();
        }
    }
}

//Output

Container: 12345

ItemNumber1: ABCDE
Quantity1: 123

ItemNumber2: FGHIJ
Quantity2: 456

ItemNumber3: KLMNO
Quantity3: 789

Then change this like so:

Match m = rx.Match(example);
while (m.Success)
{
Console.WriteLine("Container: {0}", m.Groups["Container"].Value);
Console.WriteLine("");
Console.WriteLine("ItemNumber1: {0}", m.Groups["ItemNumber1"].Value);
Console.WriteLine("Quantity1: {0}", m.Groups["Quantity1"].Value);
Console.WriteLine("");
Console.WriteLine("ItemNumber2: {0}", m.Groups["ItemNumber2"].Value);
Console.WriteLine("Quantity2: {0}", m.Groups["Quantity2"].Value);
Console.WriteLine("");
Console.WriteLine("ItemNumber3: {0}", m.Groups["ItemNumber3"].Value);
Console.WriteLine("Quantity3: {0}", m.Groups["Quantity3"].Value);
Console.WriteLine("");
m = m.NextMatch();
}
Console.ReadLine();

If I misunderstood you, provide about 4 or 5 samples.

Yea, obviously there is a misunderstanding. I am not concerned about the Groups - I am trying to work with multiple Captures for the groups.

Let's go with a simpler example. I have a data pattern such as "product, serial, serial, serial, serial, serial, ..." where the string will always begin with a 6 digit product number followed by 1 or more 8-character serial numbers and is comma-delimited (whitespace before the delimiter is ignored). I can have just one serial number or I can have 100 serial numbers in the string. I have no idea.

I want to capture the product number and each serial number that appears in the string. I've tried this regular expression pattern:

"^(?<product>\d{6})(?:\s*,(?<serial>\w{8}))+"

Using the following code:

Match m = regex.Match(input);

if (m.Success)
{
    string[] groupNames = regex.GetGroupNames();

    RegularExpressions.Capture capture;
    RegularExpressions.Group group;
    StringBuilder db = new StringBuilder();

    foreach (string groupName in groupNames)
    {
        // There is always a group "0" at index 0 that contains the full string - ignore!
        if (groupName != "0")
        {
            group = match.Groups[groupName];

            for (int i = 0; i < group.Captures.Count; i++)
            {
                capture = group.Captures[i];

                sb.AppendFormat("'{0}': {1}", groupName, capture.Value);
                sb.AppendLine();
            }
        }
    }

    Console.Write(sb.ToString());
}

Given the data:

123456 ,A1B2C3D4 ,E5F6G7H8 ,I9J0K1L2 ,M3N4O5P6

I would expect the output to be:

'product': 123456
'serial': A1B2C3D4
'serial': E5F6G7H8
'serial': I9J0K1L2
'serial': M3N4O5P6

This is not the case when I use the plus sign as the repeater. Instead I get:

'product': 123456
'serial': M3N4O5P6

However, if I change the pattern to:

"^(?<product>\d{6})(?:\s*,(?<serial>\w{8})){4}"

I get the expected/desired output. Except I can't use this pattern because the number of repetitions is 1-n. Oh, and using {1,} behaves the same as the plus sign - which was expected.

So, my question is how to setup the pattern so I can support 1-n repetitions of the serial number group, with the preceding comma delimiter, so that the named group will return multiple captures when they occur in the input string?

I tested your code and didn't have any trouble.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            String test = "123456 ,A1B2C3D4 ,E5F6G7H8 ,I9J0K1L2 ,M3N4O5P6";
            Regex rx = new Regex(@"^(?<product>\d{6})(?:\s*,(?<serial>\w{8}))+");
            Match m = rx.Match(test);
            if (m.Success)
            {
                Capture capture;
                Group group;
                StringBuilder sb = new StringBuilder();

                string[] groupNames = rx.GetGroupNames();
                foreach (string groupName in groupNames)
                {
                    // There is always a group "0" at index 0 that contains the full string - ignore!
                    if (groupName != "0")
                    {
                        group = m.Groups[groupName];

                        for (int i = 0; i < group.Captures.Count; i++)
                        {
                            capture = group.Captures[i];
                            sb.AppendFormat("'{0}': {1}", groupName, capture.Value);
                            sb.AppendLine();
                        }
                    }
                }

            }
        }
    }
}

Ah, I figured out the difference! In my testing, instead of "\s*" before the comma delimiter, I was using ".*". Apparently this is what's causing the problem. I take the exact code you have above and use the period, I get only the last serial - just as I was describing.

Any idea why the period in this place would make such a difference?