Convertir le résultat des correspondances d'une expression rationnelle en une liste de chaînes de caractères.

Question

Comment convertir la liste des résultats d'une expression rationnelle en List<string> ? J'ai cette fonction mais elle génère toujours une exception,

Impossible de convertir un objet de type 'System.Text.RegularExpressions.Match' en un objet de type 'System.Text.RegularExpressions.Match'. vers le type 'System.Text.RegularExpressions.CaptureCollection'.

public static List<string> ExtractMatch(string content, string pattern)
{
    List<string> _returnValue = new List<string>();
    Match _matchList = Regex.Match(content, pattern);
    while (_matchList.Success)
    {
        foreach (Group _group in _matchList.Groups)
        {
            foreach (CaptureCollection _captures in _group.Captures) // error
            {
                foreach (Capture _cap in _captures)
                {
                    _returnValue.Add(_cap.ToString());
                }
            }
        }
    }
    return _returnValue;
}

Si j'ai cette chaîne,

I have a dog and a cat.

expressions rationnelles

dog|cat

Je veux que la fonction renvoie un résultat dans List<string>

dog
cat

Answer 1

Avec la Regex que vous avez, vous devez utiliser Regex.Matches pour obtenir la liste finale des chaînes comme vous le souhaitez :

MatchCollection matchList = Regex.Matches(Content, Pattern);
var list = matchList.Cast<Match>().Select(match => match.Value).ToList();

Answer 2

Pour obtenir une simple liste de correspondances Regex, vous pouvez :

var lookfor = @"something (with) multiple (pattern) (groups)";
var found = Regex.Matches(source, lookfor, regexoptions);
var captured = found
                // linq-ify into list
                .Cast<Match>()
                // flatten to single list
                .SelectMany(o =>
                    // linq-ify
                    o.Groups.Cast<Capture>()
                        // don't need the pattern
                        .Skip(1)
                        // select what you wanted
                        .Select(c => c.Value));

Cette opération permet d'"aplatir" toutes les valeurs capturées en une seule liste. Pour gérer les groupes de capture, utilisez Select plutôt que SelectMany pour obtenir une liste de listes.

Answer 3

Une solution possible en utilisant Linq :

using System.Linq;
using System.Text.RegularExpressions;

static class Program {
    static void Main(string[] aargs) {
        string value = "I have a dog and a cat.";
        Regex regex = new Regex("dog|cat");
        var matchesList = (from Match m in regex.Matches(value) select m.Value).ToList();
    }
}

Answer 4

Voici une autre solution qui s'intégrera bien dans votre code.

while (_matchList.Success)
{
    _returnValue.Add(_matchList.Value);
    _matchList = _matchList.NextMatch();
}

Answer 5

Historiquement, les collections Regex n'ont pas implémenté les interfaces génériques de collection, et les méthodes d'extension LINQ que vous utilisez opèrent sur les interfaces génériques. MatchCollection a été mis à jour dans .NET Core pour implémenter IList, et peut donc être utilisé avec la méthode Selectextension, mais lorsque vous passez à .NET Standard 2.0, cette implémentation d'interface n'existe pas, et vous ne pouvez donc pas simplement appelerSelect. Au lieu de cela, vous devrez utiliser la méthode LINQ Cast o OfType pour les convertir en IEnumerable Vous pouvez ensuite utiliser Select sur ce point. J'espère que cela vous aidera.

Exemple

Regex wordMatcher = new Regex(@"\p{L}+");
return wordMatcher.Matches(text).Cast<Match>().Select(c => c.Value);

Regex wordMatcher = new Regex(@"\p{L}+");
return wordMatcher.Matches(text).OfType<Match>().Select(c => c.Value);