.net正则表达式以捕获组以及其他所有内容

Question

I am trying to create a .net regex that will capture the whole string into different groups. Capturing the groups is easy but capturing the rest is beyond me.

The [BBCode] markers could happen anywhere in the string, or be the only thing, or not be present at all. There also maybe [ brackets ] in the string.

Having group names would be a bonus.

class Program
{
    static void Main(string[] args)
    {
        string input = "thinking [ of using ] BBCode format [A=16] and [E=2] here [V=8] and so on";
        string regexString = @"((\[A=[0-9]+\])|(\[E=[0-9]+\])|(\[V=[0-9]+\]))";
        MatchCollection matches = Regex.Matches(input, regexString);

        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }
   }
}

The result I am after is (one group per line)

thinking [ of using ] BBCode format

[A=16]

and

[E=2]

here

[V=8]

and so on

Answer 1

    string input = "thinking of[ using BBCode format [A=16] here [E=2] and [V=8] and so on";
    var firstText= Regex.Match(input, @".+?(?=\[A)"); //Match until [A
    Console.WriteLine(firstText); //thinking of[ using BBCode format 
    input = Regex.Replace(input, @".+?(?=\[A)", "");
    var AValue = Regex.Match(input, @"\[A=[0-9]+\]"); //Match the value of A
    input = Regex.Replace(input, @"\[A=[0-9]+\] ", "");
    Console.WriteLine(AValue); //[A=16]
    var AText = Regex.Match(input, @".+?(?=\[)"); //Match the text after A
    Console.WriteLine(AText); // here

One huge regex is hard to understand, so I would just use some more lines on this. This for example matches the wanted text and then removes it from the input. This way you can capture the groups one by one and it's clear which part of the code captures which text, in case the regex needs to be modified in the future.

Answer 2

The regex itself is actually rather simple:

var input = "thinking [ of using ] BBCode format [A=16] and [E=2] here [V=8] and so on";

var pattern = @"^(?:(.*?)(\[[AEV]=\d+\]))*(.*?)$";

var match = Regex.Match(input, pattern);

The issue however is that you usually cannot capture variable count of groups. .NET supports this though, but you need to go through the groups and their captures to actually get all the parts you need. The full code would look like this:

var input = "thinking [ of using ] BBCode format [A=16] and [E=2] here [V=8] and so on";

var pattern = @"^(?:(.*?)(\[[AEV]=\d+\]))*(.*?)$";

var match = Regex.Match(input, pattern);

var captures = 
    match
        .Groups
        .OfType<Group>()
        .Skip(1) // first Group is the whole Match itself
        .SelectMany(g => g.Captures.OfType<Capture>())
        .OrderBy(c => c.Index); // order the captures by index to get them in appearance order, not in group order

foreach (var capture in captures)
{
    System.Console.WriteLine(capture.Value);
}

This can be easily extended to support group names (does not seem very valuable though) or other tags.