Klassen regulärer Ausdrücke
Aktualisiert: November 2007
In den folgenden Abschnitten werden Klassen regulärer Ausdrücke in .NET Framework beschrieben.
Regex
Die Regex-Klasse stellt einen unveränderlichen (schreibgeschützten) regulären Ausdruck dar. Sie enthält auch statische Methoden, mit denen andere Klassen von regulären Ausdrücken verwendet werden können, ohne dass Instanzen der anderen Klassen explizit erstellt werden.
Durch das folgende Codebeispiel wird eine Instanz der Regex-Klasse erzeugt und beim Initialisieren des Objekts ein einfacher regulärer Ausdruck definiert. Beachten Sie die Verwendung des zusätzlichen umgekehrten Schrägstrichs als Escapezeichen, der den umgekehrten Schrägstrich in der Zeichenklasse, die auf \s-Übereinstimmungen prüft, als Literalzeichen auszeichnet.
' Declare object variable of type Regex.
Dim r As Regex
' Create a Regex object and define its regular expression.
r = New Regex("\s2000")
// Declare object variable of type Regex.
Regex r;
// Create a Regex object and define its regular expression.
r = new Regex("\\s2000");
Match
Die Match-Klasse stellt die Ergebnisse einer Operation dar, mit der nach Übereinstimmungen mit einem regulären Ausdruck gesucht wird. Im folgenden Beispiel wird die Match -Methode der Regex -Klasse verwendet, um bei der Suche nach der ersten Übereinstimmung in der Eingabezeichenfolge ein Objekt des Typs Match zurückzugeben. Die Match.Success-Eigenschaft der Match-Klasse wird verwendet, um anzuzeigen, ob eine Übereinstimmung gefunden wurde.
' Create a new Regex object.
Dim r As New Regex("abc")
' Find a single match in the input string.
Dim m As Match = r.Match("123abc456")
If m.Success Then
' Print out the character position where a match was found.
Console.WriteLine("Found match at position " & m.Index.ToString())
End If
' The example displays the following output:
' Found match at position 3
// Create a new Regex object.
Regex r = new Regex("abc");
// Find a single match in the string.
Match m = r.Match("123abc456");
if (m.Success)
{
// Print out the character position where a match was found.
Console.WriteLine("Found match at position " + m.Index);
}
// The example displays the following output:
// Found match at position 3
MatchCollection
Die MatchCollection-Klasse stellt eine Folge nicht überlappender Suchergebnisse dar. Die Auflistung ist unveränderlich (schreibgeschützt) und enthält keinen öffentlichen Konstruktor. Instanzen von MatchCollection werden von der Regex.Matches-Methode zurückgegeben.
Im folgenden Beispiel wird die Matches-Methode der Regex-Klasse verwendet, um alle in der Eingabezeichenfolge gefundenen Suchergebnisse in eine MatchCollection aufzunehmen. Durch das Beispiel wird die Auflistung in ein Zeichenfolgenarray kopiert, das die Suchergebnisse sowie ein ganzzahliges Array mit Angaben zur Position eines jeden Suchergebnisses enthält.
Dim mc As MatchCollection
Dim results As New List(Of String)
Dim matchposition As New List(Of Integer)
' Create a new Regex object and define the regular expression.
Dim r As New Regex("abc")
' Use the Matches method to find all matches in the input string.
mc = r.Matches("123abc4abcd")
' Loop through the match collection to retrieve all
' matches and positions.
For i As Integer = 0 To mc.Count - 1
' Add the match string to the string array.
results.Add(mc(i).Value)
' Record the character position where the match was found.
matchposition.Add(mc(i).Index)
Next i
' List the results.
For ctr As Integer = 0 To Results.Count - 1
Console.WriteLine("'{0}' found at position {1}.", _
results(ctr), matchposition(ctr))
Next
' The example displays the following output:
' 'abc' found at position 3.
' 'abc' found at position 7.
MatchCollection mc;
List<string> results = new List<string>();
List<int> matchposition = new List<int>();
// Create a new Regex object and define the regular expression.
Regex r = new Regex("abc");
// Use the Matches method to find all matches in the input string.
mc = r.Matches("123abc4abcd");
// Loop through the match collection to retrieve all
// matches and positions.
for (int i = 0; i < mc.Count; i++)
{
// Add the match string to the string array.
results.Add(mc[i].Value);
// Record the character position where the match was found.
matchposition.Add(mc[i].Index);
}
// List the results.
for(int ctr = 0; ctr <= results.Count - 1; ctr++)
Console.WriteLine("'{0}' found at position {1}.", results[ctr], matchposition[ctr]);
// The example displays the following output:
// 'abc' found at position 3.
// 'abc' found at position 7.
GroupCollection
Die GroupCollection-Klasse stellt eine Auflistung der aufgezeichneten Gruppen dar und gibt die Menge der aufgezeichneten Gruppen in einer einzelnen Übereinstimmung zurück. Die Auflistung ist unveränderlich (schreibgeschützt) und enthält keinen öffentlichen Konstruktor. Instanzen von GroupCollection werden in derjenigen Auflistung zurückgegeben, die durch die Match.Groups-Eigenschaft zurückgegeben wird.
Im folgenden Beispiel wird die Anzahl der durch einen regulären Ausdruck aufgezeichneten Gruppen ermittelt und ausgedruckt. Das Extrahieren einzelner Suchergebnisse aus jedem Member einer Gruppenauflistung wird im CaptureCollection-Beispiel im folgenden Abschnitt beschrieben.
' Define groups "abc", "ab", and "b".
Dim r As New Regex("(a(b))c")
Dim m As Match = r.Match("abdabc")
Console.WriteLine("Number of groups found = " _
& m.Groups.Count)
' The example displays the following output:
' Number of groups found = 3
// Define groups "abc", "ab", and "b".
Regex r = new Regex("(a(b))c");
Match m = r.Match("abdabc");
Console.WriteLine("Number of groups found = " + m.Groups.Count);
// The example displays the following output:
// Number of groups found = 3
CaptureCollection
Die CaptureCollection-Klasse stellt eine Folge aufgezeichneter Teilzeichenfolgen dar und gibt die Menge der von einer einzelnen aufzeichnenden Gruppe ausgeführten Aufzeichnungen zurück. Mithilfe von Quantifizierern kann eine Gruppe mehr als eine Zeichenfolge in einem einzelnen Suchergebnis aufzeichnen. Die Captures-Eigenschaft, ein Objekt der CaptureCollection-Klasse, steht als Member der Match-Klasse und der Group-Klasse zur Verfügung, um den Zugriff auf eine Menge aufgezeichneter Teilzeichenfolgen zu erleichtern.
Ein Beispiel: Wenn Sie den regulären Ausdruck "((a(b))c)+" (der Quantifizierer "+" legt fest, dass nach einem oder mehreren Ergebnissen gesucht wird) verwenden, um Übereinstimmungen in der Zeichenfolge "abcabcabc" zu finden, enthält CaptureCollection für jede übereinstimmende Group von Teilzeichenfolgen drei Member.
Im folgenden Beispiel wird der reguläre Ausdruck (Abc)+ verwendet, um nach einer oder mehreren Übereinstimmungen in der Zeichenfolge "XYZAbcAbcAbcXYZAbcAb" zu suchen. Das Beispiel veranschaulicht die Verwendung der Captures-Eigenschaft, um mehrere Gruppen aufgezeichneter Teilzeichenfolgen zurückzugeben.
Dim counter As Integer
Dim m As Match
Dim cc As CaptureCollection
Dim gc As GroupCollection
' Look for groupings of "Abc".
Dim r As New Regex("(Abc)+")
' Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb")
gc = m.Groups
' Display the number of groups.
Console.WriteLine("Captured groups = " & gc.Count.ToString())
' Loop through each group.
Dim i, ii As Integer
For i = 0 To gc.Count - 1
cc = gc(i).Captures
counter = cc.Count
' Display the number of captures in this group.
Console.WriteLine("Captures count = " & counter.ToString())
' Loop through each capture in the group.
For ii = 0 To counter - 1
' Display the capture and its position.
Console.WriteLine(cc(ii).ToString() _
& " Starts at character " & cc(ii).Index.ToString())
Next ii
Next i
' The example displays the following output:
' Captured groups = 2
' Captures count = 1
' AbcAbcAbc Starts at character 3
' Captures count = 3
' Abc Starts at character 3
' Abc Starts at character 6
' Abc Starts at character 9
int counter;
Match m;
CaptureCollection cc;
GroupCollection gc;
// Look for groupings of "Abc".
Regex r = new Regex("(Abc)+");
// Define the string to search.
m = r.Match("XYZAbcAbcAbcXYZAbcAb");
gc = m.Groups;
// Display the number of groups.
Console.WriteLine("Captured groups = " + gc.Count.ToString());
// Loop through each group.
for (int i=0; i < gc.Count; i++)
{
cc = gc[i].Captures;
counter = cc.Count;
// Display the number of captures in this group.
Console.WriteLine("Captures count = " + counter.ToString());
// Loop through each capture in the group.
for (int ii = 0; ii < counter; ii++)
{
// Display the capture and its position.
Console.WriteLine(cc[ii] + " Starts at character " +
cc[ii].Index);
}
}
}
// The example displays the following output:
// Captured groups = 2
// Captures count = 1
// AbcAbcAbc Starts at character 3
// Captures count = 3
// Abc Starts at character 3
// Abc Starts at character 6
// Abc Starts at character 9
Group
Die Group-Klasse stellt die von einer einzelnen Gruppe aufgezeichneten Ergebnisse dar. Da Group durch Anwendung von Quantifizierern keine, eine oder mehrere Zeichenfolgen als einzelnes Suchergebnis speichern kann, ist darin eine Auflistung von Capture-Objekten enthalten. Da Group von Capture erbt, kann auf die zuletzt aufgezeichnete Teilzeichenfolge direkt zugegriffen werden (die Group-Instanz selbst ist äquivalent zum letzten Element der von der Captures-Eigenschaft zurückgegebenen Auflistung).
Instanzen von Group werden durch Indizieren des GroupCollection-Objekts zurückgegeben, das von der Groups-Eigenschaft zurückgegeben wurde. Der Indexer kann eine Gruppennummer oder der Name einer Aufzeichnungsgruppe sein, wenn das Gruppierungskonstrukt "(?<groupname>)" verwendet wird. In C#-Code können Sie beispielsweise Match.Groups[groupnum] oder Match.Groups["groupname"] verwenden. In Visual Basic-Code können Sie Match.Groups(groupnum) oder Match.Groups("groupname") verwenden.
Im folgenden Codebeispiel werden verschachtelte Gruppierungskonstrukte verwendet, um Teilzeichenfolgen in Gruppen aufzuzeichnen.
Dim matchposition As New List(Of Integer)
Dim results As New List(Of String)
' Define substrings abc, ab, b.
Dim r As New Regex("(a(b))c")
Dim m As Match = r.Match("abdabc")
Dim i As Integer = 0
While Not (m.Groups(i).Value = "")
' Add groups to string array.
results.Add(m.Groups(i).Value)
' Record character position.
matchposition.Add(m.Groups(i).Index)
i += 1
End While
' Display the capture groups.
For ctr As Integer = 0 to results.Count - 1
Console.WriteLine("{0} at position {1}", _
results(ctr), matchposition(ctr))
Next
' The example displays the following output:
' abc at position 3
' ab at position 3
' b at position 4
List<int> matchposition = new List<int>();
List<string> results = new List<string>();
// Define substrings abc, ab, b.
Regex r = new Regex("(a(b))c");
Match m = r.Match("abdabc");
for (int i = 0; m.Groups[i].Value != ""; i++)
{
// Add groups to string array.
results.Add(m.Groups[i].Value);
// Record character position.
matchposition.Add(m.Groups[i].Index);
}
// Display the capture groups.
for (int ctr = 0; ctr < results.Count; ctr++)
Console.WriteLine("{0} at position {1}",
results[ctr], matchposition[ctr]);
// The example displays the following output:
// abc at position 3
// ab at position 3
// b at position 4
Im folgenden Codebeispiel werden benannte Gruppierungskonstrukte verwendet, um Teilzeichenfolgen in einer Zeichenfolge zu suchen, die Daten in einem Format der Art "DATENNAME:WERT" enthält. Durch den regulären Ausdruck werden diese am Doppelpunkt (:) getrennt.
Dim r As New Regex("^(?<name>\w+):(?<value>\w+)")
Dim m As Match = r.Match("Section1:119900")
Console.WriteLine(m.Groups("name").Value)
Console.WriteLine(m.Groups("value").Value)
' The example displays the following output:
' Section1
' 119900
Regex r = new Regex("^(?<name>\\w+):(?<value>\\w+)");
Match m = r.Match("Section1:119900");
Console.WriteLine(m.Groups["name"].Value);
Console.WriteLine(m.Groups["value"].Value);
// The example displays the following output:
// Section1
// 119900
Capture
Die Capture-Klasse enthält die Ergebnisse einer einzelnen Teilausdrucksuche.
Im folgenden Beispiel wird eine Group-Auflistung durchlaufen und die Capture-Auflistung aus jedem Member von Group extrahiert. Ferner wird der Variablen posn die Position der Teilzeichenfolge innerhalb der Originalzeichenfolge zugeordnet und der Variablen length die Länge der gefundenen Zeichenfolge.
Dim r As Regex
Dim m As Match
Dim cc As CaptureCollection
Dim posn, length As Integer
r = New Regex("(abc)+")
m = r.Match("bcabcabc")
Dim i, j As Integer
i = 0
Do While m.Groups(i).Value <> ""
Console.WriteLine(m.Groups(i).Value)
' Grab the Collection for Group(i).
cc = m.Groups(i).Captures
For j = 0 To cc.Count - 1
Console.WriteLine(" Capture at position {0} for {1} characters.", _
cc(j).Length, cc(j).Index)
' Position of Capture object.
posn = cc(j).Index
' Length of Capture object.
length = cc(j).Length
Next j
i += 1
Loop
' The example displays the following output:
' abcabc
' Capture at position 6 for 2 characters.
' abc
' Capture at position 3 for 2 characters.
' Capture at position 3 for 5 characters.
Regex r;
Match m;
CaptureCollection cc;
int posn, length;
r = new Regex("(abc)+");
m = r.Match("bcabcabc");
for (int i=0; m.Groups[i].Value != ""; i++)
{
Console.WriteLine(m.Groups[i].Value);
// Capture the Collection for Group(i).
cc = m.Groups[i].Captures;
for (int j = 0; j < cc.Count; j++)
{
Console.WriteLine(" Capture at position {0} for {1} characters.",
cc[j].Length, cc[j].Index);
// Position of Capture object.
posn = cc[j].Index;
// Length of Capture object.
length = cc[j].Length;
}
}
// The example displays the following output:
// abcabc
// Capture at position 6 for 2 characters.
// abc
// Capture at position 3 for 2 characters.
// Capture at position 3 for 5 characters.
Siehe auch
Referenz
System.Text.RegularExpressions