C# Regex: retourner une collection de résultats

Question

string: "<something><or><other>" 
regex pattern: "<(\w+)><(\w+)><(\w+)>" 

Comment faire un appel regex qui me renvoie une collection de résultats contenant tout entre les parenthèses? Par exemple, je voudrais un ensemble de résultats de {"quelque chose", "ou", "autre"}.

Pour les points bonus, comment s'appelle-t-il? Captures? Capturer des groupes? Une sorte de gabarit? J'ai l'impression que si je connaissais la bonne terminologie, je pourrais la rechercher.

Merci.

Answer 1

Ils sont généralement appelés groupes de capture et vous pouvez obtenir e capture comme indiqué:

Regex regex = new Regex(@"some (pattern)"); 
Match m = regex.Match("some pattern"); 

foreach (Capture c in m.Groups) { 
    Console.WriteLine(c.Value); // write the value to the console "pattern" 
} 

m.Groups.Count vous permettra de savoir combien de groupes appariés, m.Groups[0] sera toujours le texte intégral de match.

Answer 2

Je pense que vous êtes à la recherche MatchCollection:

Représente l'ensemble des succès correspondances trouvées en appliquant itérativement un modèle d'expression régulière à la chaîne d'entrée .

Exemple:

string input = "<something><or><other>"; 
string pattern = "(?<=<)[^>]*(?=>)"; 

MatchCollection matches = Regex.Matches(input, pattern); 

foreach (Match match in matches) 
{ 
    Console.WriteLine(match.ToString()); // do something with match here 
} 

Edit: regex Changé de ceci:
<(\w+)><(\w+)><(\w+)>
à ceci:
(?<=<)[^>]*(?=>)

Answer 3

Utilisez MatchCollection. EDIT: J'ai oublié de changer la regex à ce que vous demandiez. Le code ci-dessous génère la sortie suivante:

quelque chose
ou
autres

Est-ce que vous cherchez?

static void Main(string[] args) 
    { 
     var str = "<something><or><other>"; 
     var re = new Regex(@"(\w+)"); 
     MatchCollection mc = re.Matches(str); 

     foreach (Match m in mc) 
     { 
      Console.WriteLine(m.Value); 
     } 
    } 

Answer 4

Il y a beaucoup de façons de la peau ce chat:

using System; 
using System.Text.RegularExpressions; 

namespace Test 
{ 
    class Test 
    { 
    static void Main(string[] args) 
    { 
     string target = @"<something><or><other>"; 

     // One group, many matches 
     Regex r1 = new Regex(@"<(\w+)>"); 
     MatchCollection mc = r1.Matches(target); 
     foreach (Match m in mc) 
     { 
     Console.WriteLine(m.Groups[1].Value); 
     } 
     Console.WriteLine(); 

     // One match, many groups 
     Regex r2 = new Regex(@"<(\w+)><(\w+)><(\w+)>"); 
     Match m2 = r2.Match(target); 
     if (m2.Success) 
     { 
     foreach (Group g in m2.Groups) 
     { 
      Console.WriteLine(g.Value); 
     } 
     } 
     Console.WriteLine(); 

     // One group, one match, many captures 
     Regex r3 = new Regex(@"(?:<(\w+)>)+"); 
     Match m3 = r3.Match(target); 
     if (m3.Success) 
     { 
     foreach (Capture c in m3.Groups[1].Captures) 
     { 
      Console.WriteLine(c.Value); 
     } 
     } 
     Console.WriteLine(); 

     // Many matches, no groups, no captures 
     Regex r4 = new Regex(@"(?<=<)\w+(?=>)"); 
     foreach (Match m in r4.Matches(target)) 
     { 
     Console.WriteLine(m.Value); 
     } 
     Console.ReadLine(); 
    } 
    } 
}