C# Regulärer Ausdruck
Regulärer AusdruckEr ist eine Suchformel, die verwendet wird, um Textmuster zu beschreiben und abzugleichen. Einfach gesagt, kann man ihn als eine spezielle Wildcard-Sprache verstehen, mit der Inhalte in Zeichenketten präzise gefunden, validiert oder ersetzt werden können.
Zum Beispiel, wenn Sie feststellen möchten, ob eine Benutzereingabe eine gültige E-Mail-Adresse oder Telefonnummer ist, oder wenn Sie alle Datumsangaben aus einem Text extrahieren möchten—das sind typische Anwendungsfälle für reguläre Ausdrücke.
Das .NET Framework verfügt über eine integrierte, voll funktionsfähige Engine für reguläre Ausdrücke, durchSystem.Text.RegularExpressionsDer Namespace bietet Unterstützung.
Ein Muster für reguläre Ausdrücke besteht aus einem oder mehreren Zeichen, Operatoren und Strukturen, die zusammen die Textregeln beschreiben, die abgeglichen werden sollen.
Wenn Sie reguläre Ausdrücke noch nicht verstehen, können Sie zuerst unserReguläre Ausdrücke - Tutorial lesen。
Einen regulären Ausdruck definieren
Reguläre Ausdrücke setzen sich aus den folgenden Arten von Bausteinen zusammen, die jeweils für unterschiedliche Abgleichfunktionen zuständig sind:
- Zeichen-Escape: Sonderzeichen als gewöhnliche Zeichen behandeln (z. B.
\.einen wörtlichen Punkt abgleichen) - Zeichenklasse: stimmt mit einem "bestimmten Typ" von Zeichen überein (z. B.
\deine beliebige Ziffer abgleichen) - Ankerpunkt: gibt die "Position" an, an der die Übereinstimmung auftritt (z. B.
^steht für den Anfang einer Zeile) - Gruppierungskonstrukt: Unterausdrücke gruppieren, um sie einfach zu erfassen oder zu referenzieren
- Quantifizierer: steuert, wie oft ein Element vorkommt (z. B.
+steht für ein- oder mehrmaliges Vorkommen) - Rückreferenzkonstrukt: verweist auf zuvor erfassten Inhalt zum erneuten Abgleichen
- Alternierungskonstrukt: implementiert die „oder“-Logik (z. B.
cat|dog) - replace: verweist in Ersetzungsvorgängen auf erfassten Inhalt
- Sonstiges Konstrukt: Hilfsfunktionen wie Inline-Optionen, Kommentare usw.
Zeichen-Escape
In regulären Ausdrücken, das Backslash-Zeichen (\) hat zwei Funktionen: Erstens maskiert es das FolgendeGewöhnliche Zeichen erhalten eine besondere Bedeutung(wie\nsteht für einen Zeilenumbruch), und zweitens wandelt esSonderzeichen werden zu literalen Zeichen maskiert(wie\.einen echten Punkt anstelle von "beliebiges Zeichen" abzugleichen).
Häufiges Missverständnis bei Anfängern: in C#-Strings,\ist selbst ein Escape-Zeichen, also muss man in Regex\d, in C#-Strings muss man schreiben"\\d", oder man verwendet einen Verbatim-String@"\d"(Empfohlen).
Die folgende Tabelle listet häufige Escape-Zeichen auf:
| Escape-Zeichen | Beschreibung | Mode | Treffer |
|---|---|---|---|
| \a | Entspricht dem Alarmzeichen (Glocke) \u0007. | \a | Das "\u0007" in "Warning!" + '\u0007' |
| \b | In Zeichenklassen entspricht es der Rücktaste \u0008. (Hinweis: Außerhalb von Zeichenklassen stellt \b eine Wortgrenze dar, siehe Abschnitt "Anker") | [\b]{3,} | "\b\b\b\b" in "\b\b\b\b" |
| \t | Entspricht dem Tabulatorzeichen \u0009. Wird häufig verwendet, um tabulatorgetrennten Text abzugleichen. | (\w+)\t | Die "Name " und "Addr " in "Name Addr " |
| \r | Entspricht dem Wagenrücklauf \u000D. (\r ist nicht gleichbedeutend mit Zeilenvorschub \n. Windows-Zeilenumbrüche sind normalerweise \r\n) | \r\n(\w+) | "\r\nHello" in "\r\nHello\nWorld." |
| \v | Entspricht dem vertikalen Tabulator \u000B. | [\v]{2,} | "\v\v\v" in "\v\v\v" |
| \f | Entspricht dem Seitenvorschub \u000C. | [\f]{2,} | "\f\f\f" in "\f\f\f" |
| \n | Entspricht dem Zeilenvorschub \u000A. Unix/Linux-Zeilenenden haben normalerweise nur \n. | \r\n(\w+) | "\r\nHello" in "\r\nHello\nWorld." |
| \e | Entspricht dem Escape-Zeichen \u001B. | \e | "\x001B" in "\x001B" |
| \ nnn | Gibt ein Zeichen mittels Oktaldarstellung an (nnn besteht aus zwei oder drei Ziffern). | \w\040\w | "a b" und "c d" in "a bc d" |
| \x nn | Gibt ein Zeichen mittels Hexadezimaldarstellung an (nn besteht aus genau zwei Ziffern). | \w\x20\w | "a b" und "c d" in "a bc d" |
| \c X \c x | Entspricht dem ASCII-Steuerzeichen, das durch X oder x angegeben wird, wobei X oder x der Buchstabe des Steuerzeichens ist. | \cC | Das "\x0003" innerhalb von "\x0003" (Strg-C) |
| \u nnnn | Entspricht einem Unicode-Zeichen in Hexadezimaldarstellung (vier Ziffern, dargestellt durch nnnn). | \w\u0020\w | "a b" und "c d" in "a bc d" |
| \ | Wenn ihm ein nicht erkanntes Escape-Zeichen folgt, stimmt es mit diesem Zeichen überein. | \d+[\+-x\*]\d+\d+[\+-x\*\d+ | Das "2+2" und "3*9" in "(2+2) * 3*9" |
Zeichenklasse
Zeichenklassen werden verwendet, um ein Zeichen unter "einem bestimmten Typ" von Zeichen abzugleichenEin beliebiges. Zum Beispiel[aeiou]stimmt mit einem beliebigen Vokal überein,\dStimmt mit einer einzelnen Ziffer überein. Dies ist eine der am häufigsten verwendeten Basisfunktionen in regulären Ausdrücken.
Die folgende Tabelle listet Zeichenklassen auf:
| Zeichenklasse | Beschreibung | Mode | Treffer |
|---|---|---|---|
| [character_group] | Stimmt mit einem einzelnen Zeichen in character_group überein. Standardmäßig wird zwischen Groß- und Kleinschreibung unterschieden. | [mn] | das 'm' in 'mat', das 'm' und 'n' in 'moon' |
| [^character_group] | Negation: Stimmt mit einem einzelnen Zeichen überein, das nicht in character_group enthalten ist. Standardmäßig wird bei Zeichen in character_group die Groß-/Kleinschreibung beachtet. | [^aei] | "v" und "l" in "avail" |
| [ first - last ] | Zeichenbereich: Entspricht jedem einzelnen Zeichen im Bereich vom ersten bis zum letzten. | [b-d] | [b-d]irds kann mit Birds, Cirds, Dirds übereinstimmen |
| . | Platzhalter: Entspricht jedem einzelnen Zeichen außer \n. Um ein wörtliches Punktzeichen (. oder \u002E) zu finden, muss ihm ein Escape-Zeichen (\.) vorangestellt werden. | a.e | "ave" in "have", "ate" in "mate" |
| \p{ name } | undnameEntspricht jedem einzelnen Zeichen in der angegebenen allgemeinen Unicode-Kategorie oder im benannten Block. | \p{Lu} | "C" und "L" in "City Lights" |
| \P{ name } | und nicht innameEntspricht jedem einzelnen Zeichen in der angegebenen allgemeinen Unicode-Kategorie oder im benannten Block. | \P{Lu} | "i", "t" und "y" in "City" |
| \w | Entspricht jedem Wortzeichen (Buchstaben, Ziffern, Unterstrich). Äquivalent zu [a-zA-Z0-9_] (im ASCII-Bereich). | \w | Die "R", "o", "m" und "1" in "Room#1" |
| \W | Entspricht jedem Nicht-Wortzeichen. Dies ist die Negation von \w. | \W | "#" in "Room#1" |
| \s | Entspricht jedem Whitespace-Zeichen (Leerzeichen, Tabulator, Zeilenumbruch usw.). | \w\s | Das "D " in "ID A1.3" |
| \S | Entspricht jedem Nicht-Whitespace-Zeichen. Dies ist die Negation von \s. | \s\S | " _" in "int __ctr" |
| \d | Entspricht einer beliebigen Dezimalziffer. Äquivalent zu [0-9]. | \d | "4" in "4 = IV" |
| \D | Entspricht jedem Zeichen, das keine Dezimalziffer ist. Dies ist die Negation von \d. | \D | Die " ", "=", " ", "I" und "V" in "4 = IV" |
Ankerpunkt
Anker (auch "Anker" genannt) stimmen mit keinem bestimmten Zeichen überein, sondern mit einer bestimmten Position in der Zeichenkette.Position. Sie sind "null-breit", verbrauchen keine Zeichen, sondern stellen nur fest, dass die aktuelle Position eine bestimmte Bedingung erfüllt.
Zum Beispiel^\d{3}bedeutet "drei Ziffern am Anfang der Zeichenkette",\bbedeutet "Grenze zwischen Wort- und Nichtwortzeichen".
Die folgende Tabelle listet Anker auf:
| Assertion | Beschreibung | Mode | Treffer |
|---|---|---|---|
| ^ | Der Treffer muss am Anfang der Zeichenkette oder Zeile beginnen. | ^\d{3} | "567" in "567-777-" |
| $ | Der Treffer muss am Ende der Zeichenkette erscheinen oder vor dem\ndavor. | -\d{4}$ | "-2012" in "8-12-2012" |
| \A | Der Treffer muss am Anfang der Zeichenkette erscheinen (nicht vom Mehrzeilenmodus beeinflusst; immer der allererste Anfang der gesamten Zeichenkette). | \A\w{4} | "Code" in "Code-007-" |
| \Z | Der Treffer muss am Ende der Zeichenkette erscheinen oder vor dem\ndavor. | -\d{3}\Z | "-007" in "Bond-901-007" |
| \z | Der Treffer muss am Ende der Zeichenkette erscheinen (striktes Ende, kein \n am Ende erlaubt). | -\d{3}\z | "-333" in "-901-333" |
| \G | Der Treffer muss dort erscheinen, wo der vorherige Treffer geendet hat. Wird häufig in Szenarien mit aufeinanderfolgenden Übereinstimmungen verwendet. | \G\(\d\) | "(1)", "(3)" und "(5)" in "(1)(3)(5)[7](9)" |
| \b | Stimmt mit einer Wortgrenze überein, also der Position zwischen einem Wort und einem Leerzeichen. | er\b | Stimmt mit "er" in "never" überein, kann aber nicht mit "er" in "verb" übereinstimmen. |
| \B | Stimmt mit einer Nicht-Wortgrenze überein. | er\B | Stimmt mit "er" in "verb" überein, kann aber nicht mit "er" in "never" übereinstimmen. |
Gruppierungskonstrukt
Gruppierungskonstrukte verwenden Klammern( )Schließen Sie einen Teil des regulären Ausdrucks ein, um einen Teilausdruck zu bilden. Die Gruppierung hat zwei Hauptzwecke:
- Erfassen: "Speichern" Sie den übereinstimmenden Teilstring zum späteren Extrahieren oder Referenzieren in der Ersetzung.
- Bereichsbeschränkung: Ermöglicht, dass Quantoren oder Alternativkonstrukte nur auf den Teilausdruck innerhalb der Gruppe angewendet werden.
Dieser Teil ist relativ schwer zu verstehen; Sie könnenRegulärer Ausdruck - Auswahl 、Lookahead- und Lookbehind-Assertions in regulären Ausdrücken lesenHilft beim Verständnis.
Die folgende Tabelle listet Gruppierungskonstrukte auf:
| Gruppierungskonstrukt | Beschreibung | Mode | Treffer |
|---|---|---|---|
| ( Teilausdruck ) | Erfasst den übereinstimmenden Teilausdruck und weist ihm eine nullbasierte Ordnungszahl zu. | (\w)\1 | "ee" in "deep" |
| (?< name >Teilausdruck) | Erfasst den übereinstimmenden Teilausdruck in einer benannten Gruppe. Benannte Gruppen sind lesbarer als numerische Nummerierung und werden für die Verwendung in komplexen regulären Ausdrücken empfohlen. | (?< double>\w)\k< double> | "ee" in "deep" |
| (?< name1 -name2 >subexpression) | Definiert eine Ausgleichsgruppendefinition. Wird verwendet, um geschachtelte Strukturen (wie gepaarte Klammern) abzugleichen, ein erweitertes Feature. | (((?'Open'\()[^\(\)]*)+((?'Close-Open'\))[^\(\)]*)+)*(?(Open)(?!))$ | "((1-3)*(3-1))" in "3+2^((1-3)*(3-1))" |
| (?: subexpression) | Definiert eine nicht erfassende Gruppe. Wird verwendet, wenn nur eine Gruppierung (Einschränkung des Gültigkeitsbereichs) erforderlich ist, ohne den übereinstimmenden Inhalt zu speichern; die Leistung ist etwas besser als bei erfassenden Gruppen. | Write(?:Line)? | Das "WriteLine" in "Console.WriteLine()" |
| (?imnsx-imnsx:subexpression) | Aktiviert oder deaktiviert die inTeilausdruckangegebenen Optionen. | A\d{2}(?i:\w+)\b | "A12xl" und "A12XL" in "A12xl A12XL a12xl" |
| (?= subexpression) | Positive Lookahead-Assertion mit Breite null. Trifft auf eine Position zu, auf die ein Teilausdruck folgt, ohne Zeichen zu verbrauchen. | \w+(?=\.) | "He is. The dog ran. The sun is out." in "is", "ran" und "out" |
| (?! subexpression) | Negative Lookahead-Assertion mit Breite null. Trifft auf eine Position zu, auf die kein Teilausdruck folgt. | \b(?!un)\w+\b | "sure" und "used" in "unsure sure unity used" |
| (?<=subexpression) | Positive Lookbehind-Assertion mit Breite null. Trifft auf eine Position zu, der ein Teilausdruck unmittelbar vorausgeht. | (?<=19)\d{2}\b | "99", "50" und "05" in "1851 1999 1950 1905 2003" |
| (?<! subexpression) | Nullbreite negative Lookbehind-Assertion. Entspricht einer Position, der kein Teilausdruck vorausgeht. | (?<!wo)man\b | "man" in "Hi woman Hi man" |
| (?> Teilausdruck) | Nicht zurückverfolgender Teilausdruck (atomare Gruppe). Sobald eine Übereinstimmung erfolgt ist, ist kein Backtracking mehr erlaubt, was in einigen Szenarien die Leistung verbessern kann. | [13579](?>A+B+) | "1ABB", "3ABB" und "5AB" in "1ABB 3ABBC 5AB 5AC" |
Beispiel
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "1851 1999 1950 1905 2003";
string pattern = @"(?<=19)\d{2}\b";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
Qualifizierer
Quantoren geben an, dass das vorangehende Element (Zeichen, Zeichenklasse oder Gruppe)wie ofterscheinen muss. Nur dann gilt die Übereinstimmung als erfolgreich.
Quantoren sind standardmäßiggierig, das heißt, sie stimmen mit so vielen Zeichen wie möglich überein. Durch das Anhängen nach einem Quantor?kann es zu einemfaulen (nicht gierigen)Muster werden, das heißt, mit so wenigen Zeichen wie möglich übereinzustimmen. Anfänger können zunächst*、+、?、{n}diese vier grundlegenden Quantoren meistern.
Die folgende Tabelle listet Quantoren auf:
| Qualifizierer | Beschreibung | Mode | Treffer |
|---|---|---|---|
| * | Stimmt mit dem vorangehenden Element null oder mehrmals überein. (Auch null Vorkommen zählen als Übereinstimmung.) | \d*\.\d | ".0"、 "19.9"、 "219.9" |
| + | Stimmt mit dem vorangehenden Element ein oder mehrmals überein. (Mindestens einmal) | "be+" | Das "bee" in "been" und das "be" in "bent" |
| ? | Stimmt mit dem vorangehenden Element null oder einmal überein. (d. h., das Element ist optional) | "rai?n" | "ran"、 "rain" |
| { n } | Entspricht dem vorherigen Element genau n-mal. | ",\d{3}" | "1,043.6" in ",043", "9,876,543,210" in ",876"、 ",543" und ",210" |
| { n ,} | Entspricht dem vorherigen Element mindestens n-mal. | "\d{2,}" | "166"、 "29"、 "1930" |
| { n , m } | Entspricht dem vorherigen Element mindestens n-mal, aber nicht mehr als m-mal. | "\d{3,5}" | Die "19302" in "166", "17668", "193024" |
| *? | Entspricht dem vorherigen Element null oder mehrmals, aber so wenige Male wie möglich (Lazy-Modus). | \d*?\.\d | ".0"、 "19.9"、 "219.9" |
| +? | Entspricht dem vorherigen Element einmal oder mehrmals, aber so wenige Male wie möglich (Lazy-Modus). | "be+?" | "be" in "been", "be" in "bent" |
| ?? | Entspricht dem vorherigen Element null oder einmal, aber so wenige Male wie möglich (Lazy-Modus). | "rai??n" | "ran"、 "rain" |
| { n }? | Entspricht dem vorhergehenden Element genau n-mal. | ",\d{3}?" | "1,043.6" in ",043", "9,876,543,210" in ",876"、 ",543" und ",210" |
| { n ,}? | Entspricht dem vorherigen Element mindestens n-mal, aber so wenige Male wie möglich. | "\d{2,}?" | "166", "29" und "1930" |
| { n , m }? | Entspricht dem vorherigen Element zwischen n und m Malen, aber so wenige Male wie möglich. | "\d{3,5}?" | "166", "17668", und die "193" und "024" in "193024" |
Rückverweis-Konstrukte
Rückverweise ermöglichen es, innerhalb desselben regulären Ausdrucks auf denInhalt zuvor erfasster Gruppenzu verweisen, wodurch erneut eine Übereinstimmung ausgeführt wird. Verwendet man beispielsweise(\w)\1kann man aufeinanderfolgende wiederholte Zeichen wie "ee", "ll" finden.
Die folgende Tabelle listet Rückverweis-Konstrukte auf:
| Rückverweis-Konstrukte | Beschreibung | Mode | Treffer |
|---|---|---|---|
| \ number | Rückverweis. Entspricht dem Wert eines nummerierten Teilausdrucks. | (\w)\1 | "ee" in "seek" |
| \k< name > | Benannte Rückreferenz. Stimmt mit dem Wert eines benannten Ausdrucks überein. Lesbarer als numerische Referenzen, empfohlen. | (?< char>\w)\k< char> | "ee" in "seek" |
Alternierungskonstrukt
Alternierungskonstrukte verwenden den senkrechten Strich|Implementiert "oder"-Logik und ermöglicht es dem regulären Ausdruck, mit einem beliebigen von mehreren Kandidatenmustern übereinzustimmen. Ähnlich dem||Operatoren.
Die folgende Tabelle listet Alternierungskonstrukte auf:
| Alternierungskonstrukt | Beschreibung | Mode | Treffer |
|---|---|---|---|
| | | Stimmt mit einem beliebigen der Elemente überein, die durch den senkrechten Strich (|) getrennt sind. | th(e|is|at) | Die Wörter "the" und "this" in "this is the day. " |
| (?( expression )yes | no ) | Wenn das Muster des regulären Ausdrucks durch den angegebenen Ausdruck abgeglichen wird, dann stimmt es mit demyesüberein; andernfalls stimmt es mit dem optionalenno-Teil überein. Der Ausdruck wird als Nullbreiten-Assertion interpretiert. | (?(A)A\d{2}\b|\b\d{3}\b) | Die "A10" und "910" in "A10 C103 910" |
| (?( name )ja | nein ) | Wenn name oder eine benannte oder nummerierte Erfassungsgruppe eine Übereinstimmung hat, dann wird dasjaabgeglichen; andernfalls wird das optionalenein abgeglichen.。 | (?< quoted>")?(?(quoted).+?"|\S+\s) | "Dogs.jpg "Yiska playing.jpg"" in Dogs.jpg and "Yiska playing.jpg" |
ersetzen
Ersetzungssyntax wird verwendet fürRegex.Replace()der MethodeReplacement Pattern StringDarin können Sie verwenden$Verwenden Sie Zahlen oder Namen, um auf zuvor erfassten Gruppeninhalt zu verweisen, was eine flexible Textumstrukturierung ermöglicht.
Die folgende Tabelle listet Zeichen auf, die für die Ersetzung verwendet werden:
| Zeichen | Beschreibung | Mode | Ersetzungsmuster | Eingabezeichenfolge | Ergebniszeichenfolge |
|---|---|---|---|---|---|
| $number | Ersetzung durch GruppennummerDie übereinstimmende Teilzeichenfolge. | \b(\w+)(\s)(\w+)\b | $3$2$1 | "eins zwei" | "zwei eins" |
| ${name} | Ersetzen durch benannte GruppeNameDer übereinstimmende Teilstring. | \b(?< word1>\w+)(\s)(?< word2>\w+)\b | ${word2} ${word1} | "eins zwei" | "zwei eins" |
| $$ | Das Ersatzzeichen "$". | \b(\d+)\s?USD | $$$1 | "103 USD" | "$103" |
| $& | Ersetzt eine Kopie der gesamten Übereinstimmung. | (\$*(\d*(\.+\d+)?){1}) | **$& | "$1.30" | "**$1.30" |
| $` | Ersetzt den gesamten Text der Eingabezeichenfolge vor der Übereinstimmung. | B+ | $` | "AABBCC" | "AAAACC" |
| $' | Ersetzt den gesamten Text der Eingabezeichenfolge nach der Übereinstimmung. | B+ | $' | "AABBCC" | "AACCCC" |
| $+ | Ersetzt die letzte erfasste Gruppe. | B+(C+) | $+ | "AABBCCDD" | AACCDD |
| $_ | Ersetzt die gesamte Eingabezeichenfolge. | B+ | $_ | "AABBCC" | "AAAABBCCCC" |
Sonstiges Konstrukt
Die folgende Tabelle listet sonstige Konstrukte auf:
| Konstruktor | Beschreibung | Beispiel |
|---|---|---|
| (?imnsx-imnsx) | Legt Optionen wie die Nichtbeachtung der Groß-/Kleinschreibung in der Mitte eines Musters fest oder deaktiviert sie. | \bA(?i)b\w+\b stimmt mit "ABA" und "Able" in "ABA Able Act" überein |
| (?#comment) | Inline-Kommentar. Dieser Kommentar endet an der ersten schließenden Klammer. | \bA(?#matches a word starting with A)\w+\b |
| # [Zeilenende] | Dieser Kommentar beginnt mit einem nicht maskierten # und setzt sich bis zum Ende der Zeile fort. | (?x)\bA\w+\b#Matches words starting with A |
Regex-Klasse
Die Regex-Klasse ist die Kernklasse für die Verwendung regulärer Ausdrücke in .NET, befindet sich inSystem.Text.RegularExpressionsunter dem Namespace. Bevor Sie sie verwenden, müssen Sie oben in der Datei Folgendes hinzufügen:
using System.Text.RegularExpressions;
Die folgende Tabelle listet einige häufig verwendete Methoden in der Regex-Klasse auf:
| Laufende Nummer | Methode & Beschreibung |
|---|---|
| 1 | public bool IsMatch(
string input
)
Bestimmt, ob die Eingabezeichenfolge Inhalt enthält, der dem Muster des regulären Ausdrucks entspricht. Wird häufig bei der Formularvalidierung verwendet, z. B. zur Validierung von Telefonnummern- oder E-Mail-Formaten. |
| 2 | public bool IsMatch(
string input,
int startat
)
Führt die Übereinstimmungsprüfung ab der angegebenen Position in der Zeichenfolge aus. |
| 3 | public static bool IsMatch(
string input,
string pattern
)
Statische Methode; es muss nicht zuerst ein Regex-Objekt erstellt werden. Übergeben Sie die Musterzeichenfolge direkt für die Übereinstimmungsermittlung. Geeignet für einmalige Anwendungsfälle. |
| 4 | public MatchCollection Matches(
string input
)
Durchsucht die Eingabezeichenfolge nach allen Übereinstimmungen und gibt eine MatchCollection zurück, die mit foreach über jedes Übereinstimmungsergebnis iteriert werden kann. |
| 5 | public string Replace(
string input,
string replacement
)
Ersetzt alle Inhalte in der Eingabezeichenfolge, die dem Muster des regulären Ausdrucks entsprechen, durch die angegebene Zeichenfolge. |
| 6 | public string[] Split(
string input
)
Teilt die Eingabezeichenfolge gemäß den durch das Muster des regulären Ausdrucks definierten Trennzeichen in ein Array von Teilzeichenfolgen auf. Flexibler als string.Split(), unterstützt komplexe Trennzeichenregeln. |
Die vollständige Liste der Eigenschaften der Regex-Klasse finden Sie in der Microsoft C#-Dokumentation.
Beispiel 1
Das folgende Beispiel gleicht Wörter ab, die mit 'S' beginnen:
Analyse:\bist eine Wortgrenze,Sstimmt mit dem Großbuchstaben S überein,\S*Entspricht null oder mehr Nicht-Leerzeichen-Zeichen; zusammen bedeutet dies "vollständige Wörter, die mit S beginnen".
Beispiel
using System.Text.RegularExpressions;
namespace RegExApplication
{
class Program
{
private static void showMatch(string text, string expr)
{
Console.WriteLine("Der Ausdruck: " + expr);
MatchCollection mc = Regex.Matches(text, expr);
foreach (Match m in mc)
{
Console.WriteLine(m);
}
}
static void Main(string[] args)
{
string str = "Tausend strahlende Sonnen";
Console.WriteLine("Wörter, die mit 'S' beginnen: ");
showMatch(str, @"\bS\S*");
Console.ReadKey();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:
Matching words that start with 'S': The Expression: \bS\S* Splendid Suns
Beispiel 2
Das folgende Beispiel findet Wörter, die mit 'm' beginnen und mit 'e' enden:
Analyse:\bmfindet Wörter, die mit m beginnen,\S*findet ein beliebiges Nicht-Whitespace-Zeichen in der Mitte,e\bErfordert ein Ende mit e, gefolgt von einer Wortgrenze; zusammen findet es alle Wörter, die mit m beginnen und mit e enden.
Beispiel
using System.Text.RegularExpressions;
namespace RegExApplication
{
class Program
{
private static void showMatch(string text, string expr)
{
Console.WriteLine("Der Ausdruck: " + expr);
MatchCollection mc = Regex.Matches(text, expr);
foreach (Match m in mc)
{
Console.WriteLine(m);
}
}
static void Main(string[] args)
{
string str = "make maze and manage to measure it";
Console.WriteLine("Passende Wörter beginnen mit 'm' und enden mit 'e':");
showMatch(str, @"\bm\S*e\b");
Console.ReadKey();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:
Matching words start with 'm' and ends with 'e': The Expression: \bm\S*e\b make maze manage measure
Beispiel 3
Das folgende Beispiel ersetzt zusätzliche Leerzeichen:
Analyse:\\s+Findet ein oder mehrere aufeinanderfolgende Whitespace-Zeichen (Leerzeichen, Tabulatoren usw.) und ersetzt sie alle durch ein einzelnes Leerzeichen, wodurch zusätzlicher Whitespace zusammengeführt wird.
Beispiel
using System.Text.RegularExpressions;
namespace RegExApplication
{
class Program
{
static void Main(string[] args)
{
string input = "Hello World ";
string pattern = "\\s+";
string replacement = " ";
Regex rgx = new Regex(pattern);
string result = rgx.Replace(input, replacement);
Console.WriteLine("Ursprüngliche Zeichenfolge: {0}", input);
Console.WriteLine("Ersetzungszeichenfolge: {0}", result);
Console.ReadKey();
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:
Original String: Hello World Replacement String: Hello World
GeneratedRegex: Quellgenerator-Optimierung (.NET 7+)
Ab .NET 7 führte C#[GeneratedRegex]Attribut (Quellgenerator), das eine wesentliche Verbesserung gegenüber dem traditionellenRegexeine wichtige Verbesserung der Klasse, speziell fürLeistungssensibleoderWiederholte VerwendungRegex-Szenarien.
Probleme traditioneller Ansätze
Traditionelle Methode verwendennew Regex(pattern)Wenn ..., erfolgen das Parsen und die Kompilierung des regulären Ausdrucks zurLaufzeit, jede Erstellung verursacht Overhead. Obwohl Sie verwenden könnenRegexOptions.CompiledVerbessert die Laufzeitgeschwindigkeit, aber die Kompilierung erfolgt weiterhin zur Laufzeit und erhöht die Startzeit und den Speicherverbrauch.
Traditionelle Methode
// Methode 1: Jedes Mal neu parsen (am langsamsten)
bool isMatch = Regex.IsMatch(input, @"\d{4}-\d{2}-\d{2}");
// Methode 2: statisches Feld + Compiled (gängige Optimierungspraxis)
private static readonly Regex DateRegex = new Regex(@"\d{4}-\d{2}-\d{2}", RegexOptions.Compiled);
Verwendung von GeneratedRegex
Nutzung[GeneratedRegex]Mit dem Attribut wird der Compiler in derKompilierungsphaseden regulären Ausdruck direkt als effizienten C#-Code generieren, ohne Laufzeit-Parsing oder -Kompilierung.
Verwendungsanforderungen: .NET 7 oder höher ist erforderlich, und die Methode musspartialMethode, die enthaltende Klasse muss ebenfalls seinpartialclass.
Grundlegende Verwendung von GeneratedRegex
using System.Text.RegularExpressions;
namespace RegExApplication
{
// Die Klasse muss als partial deklariert werden
partial class Program
{
// Verwenden Sie das [GeneratedRegex]-Attribut, der Compiler generiert die Implementierung automatisch
[GeneratedRegex(@"\d{4}-\d{2}-\d{2}")]
private static partial Regex DateRegex();
// Du kannst auch Optionen hinzufügen, wie z. B. das Ignorieren der Groß-/Kleinschreibung
[GeneratedRegex(@"\bS\S*", RegexOptions.IgnoreCase)]
private static partial Regex StartsWithSRegex();
static void Main(string[] args)
{
string input = "Heute ist 2024-06-18, nächstes Ereignis: 2025-01-01";
// Verwende es wie einen normalen Methodenaufruf; gibt eine Regex-Instanz zurück
foreach (Match m in DateRegex().Matches(input))
{
Console.WriteLine("Gefundenes Datum:" + m.Value);
}
// Überprüfen, ob es übereinstimmt
Console.WriteLine(StartsWithSRegex().IsMatch("Splendid")); // True
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:
找到日期:2024-06-18 找到日期:2025-01-01 True
GeneratedRegex vs. traditionelle Regex
Die folgende Tabelle vergleicht die beiden Ansätze aus mehreren Dimensionen, um Ihnen die Wahl der geeigneten Verwendung zu erleichtern:
| Vergleichsdimension | Traditionelle Regex | GeneratedRegex (Quellgenerator) | Empfohlen |
|---|---|---|---|
| Mindestversionsanforderung | .NET Framework / .NET Core Alle Versionen unterstützt | .NET 7 und höher | — |
| Kompilierungszeitpunkt | Parsing und Kompilierung zur Laufzeit | Zur Kompilierungszeit (Buildzeit) generiert der Roslyn-Quellgenerator Code | GeneratedRegex |
| Ausführungsleistung | Normal: langsamer; mit der Option „Compiled“: schneller, aber hoher Startaufwand | Am schnellsten, nahe an der Leistung von handgeschriebenem Code, und kein Start-Overhead | GeneratedRegex |
| Speicherverbrauch | Der Compiled-Modus erzeugt IL-Code und hat einen höheren Speicherverbrauch | Es erzeugt gewöhnlichen C#-Code, der speicherfreundlicher ist | GeneratedRegex |
| AOT-Kompatibilität | RegexOptions.Compiled ist nicht mit AOT (Ahead-of-Time-Kompilierung) kompatibel | Vollständig kompatibel mit Native AOT, geeignet zum Veröffentlichen eigenständiger Anwendungen | GeneratedRegex |
| Lesbarkeit des Codes | Die Musterzeichenfolge wird direkt in den Code geschrieben, was intuitiver ist | Erfordert das Definieren einer partiellen Methode, und die Codestruktur ist etwas komplexer | Traditionelle Regex (einfache Szenarien) |
| Dynamischer Modus | Unterstützt, das Muster kann eine Laufzeitvariable sein | Nicht unterstützt, das Muster muss eine Kompilierzeitkonstante sein | Traditionelle Regex (dynamische Szenarien) |
| Unterstützung beim Debuggen | Gewöhnlich | Der generierte Code kann direkt eingesehen und gedebuggt werden, was ihn transparenter macht | GeneratedRegex |
| Anwendbare Szenarien | Einmalige Verwendung, dynamische Muster, Legacy-.NET-Projekte | Häufige Aufrufe, leistungskritisch, AOT-Veröffentlichung, neue .NET-Projekte | Hängt vom Kontext ab |
Verwendungshinweise
- Wenn Sie.NET 7+verwenden und das Regex-Muster fest ist,bevorzugen Sie die Verwendung von
[GeneratedRegex]。 - Wenn das Regex-Muster zur Laufzeit dynamisch erstellt werden muss (z. B. aus Benutzereingaben generiert), nur die traditionelle
new Regex(pattern)。 - Wenn das ProjektNative AOTbeim Veröffentlichen unterstützen muss (z. B. den AOT-Modus von .NET 8), verwenden Sie unbedingt
[GeneratedRegex]stattRegexOptions.Compiled。 - Für Anfänger können Sie zunächst die traditionelle Methode zum Lernen und Üben verwenden. Nachdem Sie die Prinzipien von Regex verstanden haben, migrieren Sie schrittweise zu
[GeneratedRegex]。
Beispiel: Verwenden von GeneratedRegex zum Validieren des E-Mail-Formats
using System.Text.RegularExpressions;
partial class EmailValidator
{
// E-Mail-Validierungsregex definieren, Groß-/Kleinschreibung ignorieren
[GeneratedRegex(@"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$", RegexOptions.IgnoreCase)]
private static partial Regex EmailRegex();
public static bool IsValidEmail(string email)
{
return EmailRegex().IsMatch(email);
}
static void Main(string[] args)
{
string[] emails = { "user@example.com", "bad-email", "hello@world.org", "missing@dot" };
foreach (var email in emails)
{
Console.WriteLine($"{email}: {(IsValidEmail(email) ? "gültig" : "Ungültig")}");
}
}
}
Wenn der obige Code kompiliert und ausgeführt wird, erzeugt er das folgende Ergebnis:
user@example.com: 有效 bad-email: 无效 hello@world.org: 有效 missing@dot: 无效Weitere Erweiterungen