Suchen / Ersetzen durch die Regex-Klasse

Wir haben bereits die Regex-Klasse und ihre Verwendung besprochen, wenn wir in einem früheren Artikel nach einem String suchen wollen. Reguläre Ausdrücke sind dafür ideal, aber ein anderer Anwendungsfall ist, wenn Sie Such- / Ersetzungsvorgänge durchführen möchten, bei denen Sie nach einem bestimmten Muster suchen und es durch etwas anderes ersetzen möchten. Die String-Klasse verfügt bereits über eine Replace() -Methode, die jedoch nur für einfache Suchen geeignet ist. Wenn Sie reguläre Ausdrücke verwenden, können Sie die Leistungsfähigkeit von Regex-Suchen nutzen und sogar erfasste Gruppen als Teil der Ersetzungszeichenfolge verwenden. Klingt das kompliziert? Keine Sorge, wir beginnen mit einem einfachen Beispiel und arbeiten dann langsam in fortgeschritteneren Anwendungsfällen.

Im vorherigen Artikel wird davon ausgegangen, dass Sie den Namespace RegularExpressions folgendermaßen importiert haben:

using System.Text.RegularExpressions;

In diesem Fall versuchen wir, mit der Verwendung regulärer Ausdrücke zu arbeiten. Wir verwenden die Methode Replace() in der Klasse Regex:

string testString = "<b>Hello, <i>world</i></b>";
Regex regex = new Regex("<[^>]+>");
string cleanString = regex.Replace(testString, "");
Console.WriteLine(cleanString);

In diesem Beispiel wird ein sehr vereinfachter Ansatz zum Entfernen von HTML-Tags aus einer Zeichenfolge angezeigt. Wir passen alles an, was von einer Reihe von spitzen Klammern (<>) umgeben ist, und dann verwenden wir die Replace() -Methode, um jedes Vorkommen durch eine leere Zeichenfolge zu ersetzen und die HTML-Tags aus der Testzeichenfolge zu entfernen.

Ersetzten mit erfassten Werten

Aber lassen Sie uns annehmen, dass Sie sie nicht wirklich entfernen wollen, sondern dass Sie die Tags in etwas verwandeln wollen, das von einem Browser nicht interpretiert wird, z.B.: durch Ersetzen der spitzen Klammern (< >) durch eckige Klammern ([]). Hier zeigen Regular Expressions wirklich ihre Stärke, denn es ist tatsächlich sehr einfach, wie diese leicht umgeschriebene Version unseres vorherigen Beispiels zeigt:

string testString = "<b>Hello, <i>world</i></b>";
Regex regex = new Regex("<([^>]+)>");
string cleanString = regex.Replace(testString, "[$1]");
Console.WriteLine(cleanString);

Ich habe gerade zwei kleine Details geändert: Ich habe der Regex eine Reihe von Klammern hinzugefügt, um eine Capture-Gruppe zu erstellen, die im Wesentlichen den Wert zwischen den spitzen Klammern in die erste Capture-Gruppe aufnimmt. In der Replace() Methode referenziere ich dies mit der speziellen Notation $1, die im Grunde genommen nur die Capture Group Nummer 1 bedeutet. Damit wird unsere Ausgabe nun so aussehen :

[b]Hello, [i]world[/i][/b]

Benannte Erfassungsgruppen

Sie können natürlich genau dasselbe tun, wenn Sie benannte Capture-Gruppen verwenden (wie im vorherigen Artikel besprochen), etwa so:

string testString = "<b>Hello, <i>world</i></b>";
Regex regex = new Regex("<(?<tagName>[^>]+)>");
string cleanString = regex.Replace(testString, "[${tagName}]");
Console.WriteLine(cleanString);

Wenn Sie benannte Erfassungsgruppen verwenden, verwenden Sie einfach die Schreibweise ${name-of-capture-group}.

Verwenden der "MatchEvaluator" -Methode

Aber wenn wir noch mehr Kontrolle darüber haben wollen, wie der Wert ersetzt wird? Wir können hierfür einen MatchEvaluator-Parameter verwenden - es ist im Grunde genommen nur eine Referenz (Delegat) für eine Methode, die jedes Mal aufgerufen wird, wenn eine Ersetzung durchgeführt werden soll, sodass Sie den Ersetzungswert ändern können, bevor er verwendet wird. Bleiben wir bei dem HTML-Beispiel, das wir bereits mehrmals verwendet haben, aber diesmal nehmen wir die Kontrolle darüber, welche HTML-Tags verwendet werden. Hier ist das vollständige Beispiel:

using System;
using System.Text.RegularExpressions;

namespace RegexSearchReplaceMethod
{
    class Program
    {
    static void Main(string[] args)
    {
        string testString = "<b>Hello, <i>world</i></b>";
        Regex regex = new Regex("<(?<tagName>[^>]+)>");
        string cleanString = regex.Replace(testString, ProcessHtmlTag);
        Console.WriteLine(cleanString);
    }

    private static string ProcessHtmlTag(Match m)
    {
        string tagName = m.Groups["tagName"].Value;
        string endTagPrefix = "";
        if(tagName.StartsWith("/"))
        {
        endTagPrefix = "/";
        tagName = tagName.Substring(1);
        }
        switch (tagName)
        {
        case "b":
            tagName = "strong";
            break;
        case "i":
            tagName = "em";
            break;
        }
        return "<" + endTagPrefix + tagName.ToLower() + ">";
    }
    }
}

Der erste Teil des Beispiels sieht genauso aus wie zuvor, aber anstatt eine Ersatzzeichenfolge anzugeben, geben wir einen Verweis auf unsere Methode ProcessHtmlTag() weiter. Wie bereits erwähnt, wird diese Methode jedes Mal aufgerufen, wenn eine Ersetzung durchgeführt wird, wobei die betreffende Übereinstimmung als Parameter verwendet wird. Das bedeutet, dass wir in unserer MatchEvaluator-Methode alle Informationen zum Match haben, damit wir entsprechend handeln können. In diesem Fall verwenden wir diese Gelegenheit, um die Tags semantischer zu gestalten, indem wir das fett gedruckte (b) -Tag durch ein starkes Tag und das kursive (i) -Tag durch ein em (em) -Tag ersetzen. Egal ob das Tag geändert wird oder nicht, wir verwandeln es in Kleinbuchstaben.

Die Verwendung eines MatchEvaluator-Parameters ist offensichtlich sehr leistungsfähig und dies ist nur ein einfaches Beispiel dafür, was erreicht werden kann.

Zusammenfassung

Such- / Ersetzungsvorgänge werden sehr mächtig, wenn Sie Reguläre Ausdrücke verwenden, und noch mehr, wenn Sie den Parameter "MatchEvaluator" verwenden, in dem die Möglichkeiten zum Bearbeiten von Strings fast endlos sind.