Klassen regulärer Ausdrücke
In den folgenden Abschnitten werden Klassen regulärer Ausdrücke in .NET Framework beschrieben.
Regex
Die Regex-Klasse verkörpert einen unveränderlichen (schreibgeschützten) regulären Ausdruck. 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 repräsentiert die Ergebnisse einer Operation, 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.
' cCreate 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.
' (Character position 3 in this case.)
Console.WriteLine("Found match at position " & m.Index.ToString())
End If
// 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.
// (Character position 3 in this case.)
Console.WriteLine("Found match at position " + m.Index);
}
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(20) As String
Dim matchposition(20) As 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.
Dim i As Integer
For i = 0 To mc.Count - 1
' Add the match string to the string array.
results(i) = mc(i).Value
' Record the character position where the match was found.
matchposition(i) = mc(i).Index
Next i
MatchCollection mc;
String[] results = new String[20];
int[] matchposition = new int[20];
// 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[i] = mc[i].Value;
// Record the character position where the match was found.
matchposition[i] = mc[i].Index;
}
GroupCollection
Die GroupCollection-Klasse stellt eine Auflistung von zu Gruppen zusammengefassten Suchergebnissen dar und gibt die Menge der Gruppen als ein einzelnes Suchergebnis 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 für eine Konsolenanwendung 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.
Imports System
Imports System.Text.RegularExpressions
Public Class RegexTest
Public Shared Sub RunTest()
' 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.ToString())
End Sub
Public Shared Sub Main()
RunTest()
End Sub
End Class
using System;
using System.Text.RegularExpressions;
public class RegexTest
{
public static void RunTest()
{
// 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);
}
public static void Main()
{
RunTest();
}
}
Folgende Ergebnisse werden zurückgegeben:
Number of groups found = 3
Number of groups found = 3
CaptureCollection
Die CaptureCollection-Klasse stellt eine Folge aufgezeichneter Teilzeichenfolgen dar und gibt die durch eine einzelne Gruppe aufgezeichnete Menge 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 für eine Konsolenanwendung 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.
Imports System
Imports System.Text.RegularExpressions
Public Class RegexTest
Public Shared Sub RunTest()
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
' Print 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
' Print number of captures in this group.
Console.WriteLine("Captures count = " & counter.ToString())
' Loop through each capture in group.
For ii = 0 To counter - 1
' Print capture and position.
Console.WriteLine(cc(ii).ToString() _
& " Starts at character " & cc(ii).Index.ToString())
Next ii
Next i
End Sub
Public Shared Sub Main()
RunTest()
End Sub
End Class
using System;
using System.Text.RegularExpressions;
public class RegexTest
{
public static void RunTest()
{
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;
// Print 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;
// Print number of captures in this group.
Console.WriteLine("Captures count = " + counter.ToString());
// Loop through each capture in group.
for (int ii = 0; ii < counter; ii++)
{
// Print capture and position.
Console.WriteLine(cc[ii] + " Starts at character " +
cc[ii].Index);
}
}
}
public static void Main() {
RunTest();
}
}
Folgende Ergebnisse werden in diesem Beispiel ausgegeben:
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
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 repräsentiert die von einer einzelnen Gruppe aufgezeichneten Ergebnisse. 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(20) As Integer
Dim results(20) As 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 = "")
' Copy groups to string array.
results(i) = m.Groups(i).Value
' Record character position.
matchposition(i) = m.Groups(i).Index
i = i + 1
End While
int[] matchposition = new int[20];
String[] results = new String[20];
// 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++)
{
// Copy groups to string array.
results[i]=m.Groups[i].Value;
// Record character position.
matchposition[i] = m.Groups[i].Index;
}
Folgende Ergebnisse werden in diesem Beispiel ausgegeben:
results(0) = "abc" matchposition(0) = 3
results(1) = "ab" matchposition(1) = 3
results(2) = "b" matchposition(2) = 4
results[0] = "abc" matchposition[0] = 3
results[1] = "ab" matchposition[1] = 3
results[2] = "b" matchposition[2] = 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")
Regex r = new Regex("^(?<name>\\w+):(?<value>\\w+)");
Match m = r.Match("Section1:119900");
Durch diesen regulären Ausdruck werden folgende Ergebnisse zurückgegeben:
m.Groups("name").Value = "Section1"
m.Groups("value").Value = "119900"
m.Groups["name"].Value = "Section1"
m.Groups["value"].Value = "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
While m.Groups(i).Value <> ""
' Grab the Collection for Group(i).
cc = m.Groups(i).Captures
For j = 0 To cc.Count - 1
' Position of Capture object.
posn = cc(j).Index
' Length of Capture object.
length = cc(j).Length
Next j
i += 1
End While
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++)
{
// Capture the Collection for Group(i).
cc = m.Groups[i].Captures;
for (int j = 0; j < cc.Count; j++)
{
// Position of Capture object.
posn = cc[j].Index;
// Length of Capture object.
length = cc[j].Length;
}
}
Siehe auch
Referenz
System.Text.RegularExpressions