Opérations de chaîne : critères de correspondance, performances et recherche basée sur l’étendue

Cet article traite de trois opérations de chaîne : le modèle d’expression régulière correspondant à System.Text.RegularExpressions.Regex, la recherche sans allocation sur ReadOnlySpan<T>et le choix d’une valeur pour des StringComparison comparaisons correctes et rapides.

Rechercher du texte spécifique à l’aide d’expressions régulières

La System.Text.RegularExpressions.Regex classe recherche des chaînes pour des modèles plutôt que des sous-chaînes fixes. La méthode statique Regex.IsMatch prend la chaîne d’entrée, un modèle et des indicateurs facultatifs RegexOptions .

L’exemple suivant recherche chaque phrase pour le mot qui ne respecte pas la casse ou le mot. Le modèle the(ir)?\s correspond the éventuellement à suivi, irpuis à un caractère d’espace blanc :

string[] sentences =
[
    "Put the water over there.",
    "They're quite thirsty.",
    "Their water bottles broke."
];

string pattern = @"the(ir)?\s";

foreach (string s in sentences)
{
    Console.Write($"{s,28}");

    if (Regex.IsMatch(s, pattern, RegexOptions.IgnoreCase))
    {
        Console.WriteLine($"  (match for '{pattern}' found)");
    }
    else
    {
        Console.WriteLine();
    }
}

Valider des chaînes par rapport à un modèle

Pour vérifier si une entrée entière correspond à une forme, ancrez le modèle avec ^ et $. L’exemple suivant vérifie que chaque chaîne est un numéro de téléphone de style AMÉRICAIN : trois chiffres, trois chiffres, quatre chiffres, séparés par des tirets :

string[] numbers =
[
    "123-555-0190",
    "444-234-22450",
    "690-555-0178",
    "146-893-232",
    "146-555-0122",
    "4007-555-0111",
    "407-555-0111",
    "407-2-5555",
    "407-555-8974",
    "407-2ab-5555",
    "690-555-8148",
    "146-893-232-"
];

string pattern = """^\d{3}-\d{3}-\d{4}$""";

foreach (string s in numbers)
{
    Console.Write($"{s,14}");
    Console.WriteLine(Regex.IsMatch(s, pattern) ? " - valid" : " - invalid");
}

Pour obtenir la syntaxe complète du modèle, consultez le langage d’expression régulière - référence rapide.

Choisir entre string les méthodes et les expressions régulières

string méthodes et Regex résolution des problèmes qui se chevauchent. Préférez les méthodes lorsque le texte que vous recherchez string est une valeur littérale, un préfixe ou un suffixe connu ou un délimiteur fixe. Ils sont plus simples à lire et plus rapidement, car ils ne paient pas le coût de compilation et d’exécution d’un modèle. Regex Atteindre lorsque la cible de recherche est une forme, telle que des altertions, des groupes facultatifs, des classes de caractères répétées ou une validation ancrée. En règle générale, si vous pouvez écrire la recherche en tant qu’un ou deux string.Contains / / StartsWithIndexOf appels, faites-le.

Rechercher à l’aide de ReadOnlySpan<char>

Lorsque vous analysez des entrées volumineuses ou exécutez une recherche sur un chemin d’accès chaud, les allocations par appel et string.Substringstring.Split peuvent dominer. ReadOnlySpan<char> vous donne une vue sur une chaîne existante (ou tableau ou mémoire tampon de pile) sans copier et MemoryExtensions fournit des équivalents basés sur des étendues des méthodes courantes string , notamment IndexOf:

ReadOnlySpan<char> input = "key1=alpha;key2=beta;key3=gamma".AsSpan();
ReadOnlySpan<char> needle = "key2=".AsSpan();

int start = input.IndexOf(needle);
if (start >= 0)
{
    ReadOnlySpan<char> rest = input[(start + needle.Length)..];
    int end = rest.IndexOf(';');
    ReadOnlySpan<char> value = end >= 0 ? rest[..end] : rest;
    Console.WriteLine($"key2 = {value}");
}
// => key2 = beta

La recherche basée sur l’étendue évite les allocations, car les tranches (input[start..], rest[..end]) sont simplement des fenêtres sur les caractères d’origine. La même approche est mise à l’échelle pour analyser des listes clé-valeur, des en-têtes et d’autres texte délimités sans jamais appeler Substring.

Considérations relatives aux performances pour StringComparison

La plupart des string méthodes d’instance ont des surcharges qui acceptent une StringComparison valeur. Méthodes telles que la String.Equals(String) valeur ordinale par défaut, mais String.Compare(String, String) par défaut pour String.IndexOf(String)la culture actuelle. Cette différence est importante de deux façons :

• Vitesse. La comparaison ordinale est un test d’octets pour octets qui s’exécute dans des boucles vectorisées serrées. La comparaison prenant en charge la culture consulte une table de tri, guide la combinaison de caractères et applique des règles spécifiques aux paramètres régionaux. Pour la même entrée, il peut s’agir d’un ordre de grandeur plus lent.
• Exactitude. La comparaison prenant en compte la culture peut plier les caractères que vous n’attendez pas (turc, allemand iß/Ià ss, ligatures). Ce comportement est approprié pour trier les noms qu’un utilisateur voit, mais incorrect pour l’analyse des identificateurs, des chemins ou des jetons de protocole.

Pour le texte défini par l’ordinateur, tel que les noms de fichiers, les URL, les en-têtes HTTP, les identificateurs et les clés de configuration, transmettez StringComparison.Ordinal ou StringComparison.OrdinalIgnoreCase explicitement. Réservez des valeurs sensibles à la culture pour le texte en langage naturel affiché aux utilisateurs. Pour obtenir des conseils complets, consultez Pratiques de comparaison des chaînes dans .NET.

Voir aussi

• Langage d’expression régulière : référence rapide
• Pratiques de comparaison des chaînes dans .NET
• Chaînes de recherche
• Fractionner des chaînes en sous-chaînes
• System.Text.RegularExpressions.Regex
• System.MemoryExtensions
• System.StringComparison