Regex-Klasse
Stellt einen unveränderlichen regulären Ausdruck dar.
Namespace: System.Text.RegularExpressions
Assembly: System (in system.dll)
Syntax
'Declaration
<SerializableAttribute> _
Public Class Regex
Implements ISerializable
'Usage
Dim instance As Regex
[SerializableAttribute]
public class Regex : ISerializable
[SerializableAttribute]
public ref class Regex : ISerializable
/** @attribute SerializableAttribute() */
public class Regex implements ISerializable
SerializableAttribute
public class Regex implements ISerializable
Hinweise
Die Regex-Klasse enthält mehrere statische Methoden, mit deren Hilfe Sie einen regulären Ausdruck verwenden können, ohne dabei ausdrücklich ein Regex-Objekt erstellen zu müssen. Die Verwendung einer statischen Methode entspricht der Erstellung eines Regex-Objekts, das einmal verwendet und dann zerstört wird.
Die Regex-Klasse kann nicht geändert werden (Schreibschutz) und ist prinzipiell threadsicher. Regex-Objekte können für jeden Thread erzeugt und von mehreren Threads gemeinsam verwendet werden. Weitere Informationen finden Sie unter Threadsicherheit.
Beispiel
Im folgenden Codebeispiel wird veranschaulicht, wie mit einem regulären Ausdruck überprüft wird, ob eine Zeichenfolge das richtige Format zum Darstellen einer Währung aufweist. Beachten Sie das umschließende ^-Token und das $-Token, die angeben, dass nicht nur ein Teil der Zeichenfolge, sondern die gesamte Zeichenfolge mit dem regulären Ausdruck übereinstimmen muss.
using System;
using System.Text.RegularExpressions;
public class Test
{
public static void Main ()
{
// Define a regular expression for currency values.
Regex rx = new Regex(@"^-?\d+(\.\d{2})?$");
// Define some test strings.
string[] tests = {"-42", "19.99", "0.001", "100 USD"};
// Check each test string against the regular expression.
foreach (string test in tests)
{
if (rx.IsMatch(test))
{
Console.WriteLine("{0} is a currency value.", test);
}
else
{
Console.WriteLine("{0} is not a currency value.", test);
}
}
}
}
#using <System.dll>
using namespace System;
using namespace System::Text::RegularExpressions;
int main()
{
// Define a regular expression for currency values.
Regex^ rx = gcnew Regex( "^-?\\d+(\\.\\d{2})?$" );
// Define some test strings.
array<String^>^tests = {"-42","19.99","0.001","100 USD"};
// Check each test string against the regular expression.
System::Collections::IEnumerator^ myEnum = tests->GetEnumerator();
while ( myEnum->MoveNext() )
{
String^ test = safe_cast<String^>(myEnum->Current);
if ( rx->IsMatch( test ) )
{
Console::WriteLine( "{0} is a currency value.", test );
}
else
{
Console::WriteLine( "{0} is not a currency value.", test );
}
}
}
import System.*;
import System.Text.RegularExpressions.*;
public class Test
{
public static void main(String[] args)
{
// Define a regular expression for currency values.
Regex rx = new Regex("^-?\\d+(\\.\\d{2})?$");
// Define some test strings.
String tests[] = { "-42", "19.99", "0.001", "100 USD" };
// Check each test string against the regular expression.
for (int iCtr = 0; iCtr < tests.get_Length(); iCtr++) {
String test = (String)tests.get_Item(iCtr);
if (rx.IsMatch(test)) {
Console.WriteLine("{0} is a currency value.", test);
}
else {
Console.WriteLine("{0} is not a currency value.", test);
}
}
} //main
} //Test
Im folgenden Codebeispiel wird veranschaulicht, wie ein regulärer Ausdruck verwendet wird, um wiederholte Vorkommen von Wörtern in einer Zeichenfolge zu suchen. Beachten Sie das (?<word>)-Konstrukt, mit dem eine Gruppe benannt wird, und das (\k<word>)-Konstrukt, mit dem später im Ausdruck auf diese Gruppe verwiesen wird.
using System;
using System.Text.RegularExpressions;
public class Test
{
public static void Main ()
{
// Define a regular expression for repeated words.
Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
RegexOptions.Compiled | RegexOptions.IgnoreCase);
// Define a test string.
string text = "The the quick brown fox fox jumped over the lazy dog dog.";
// Find matches.
MatchCollection matches = rx.Matches(text);
// Report the number of matches found.
Console.WriteLine("{0} matches found.", matches.Count);
// Report on each match.
foreach (Match match in matches)
{
string word = match.Groups["word"].Value;
int index = match.Index;
Console.WriteLine("{0} repeated at position {1}", word, index);
}
}
}
#using <System.dll>
using namespace System;
using namespace System::Text::RegularExpressions;
int main()
{
// Define a regular expression for repeated words.
Regex^ rx = gcnew Regex( "\\b(?<word>\\w+)\\s+(\\k<word>)\\b",static_cast<RegexOptions>(RegexOptions::Compiled | RegexOptions::IgnoreCase) );
// Define a test string.
String^ text = "The the quick brown fox fox jumped over the lazy dog dog.";
// Find matches.
MatchCollection^ matches = rx->Matches( text );
// Report the number of matches found.
Console::WriteLine( "{0} matches found.", matches->Count );
// Report on each match.
for each (Match^ match in matches)
{
String^ word = match->Groups["word"]->Value;
int index = match->Index;
Console::WriteLine("{0} repeated at position {1}", word, index);
}
}
import System.*;
import System.Text.RegularExpressions.*;
public class Test
{
public static void main(String[] args)
{
// Define a regular expression for repeated words.
Regex rx = new Regex("\\b(?<word>\\w+)\\s+(\\k<word>)\\b",
RegexOptions.Compiled | RegexOptions.IgnoreCase);
// Define a test string.
String text = "The the quick brown fox fox jumped over the "
+ "lazy dog dog.";
// Find matches.
MatchCollection matches = rx.Matches(text);
// Report the number of matches found.
Console.WriteLine("{0} matches found.", (Int32)matches.get_Count());
// Report on each match.
for (int iCtr = 0; iCtr < matches.get_Count(); iCtr++) {
Match match = matches.get_Item(iCtr);
String word = match.get_Groups().get_Item("word").get_Value();
int index = match.get_Index();
Console.WriteLine("{0} repeated at position {1}", word,
(Int32)index);
}
} //main
} //Test
Vererbungshierarchie
System.Object
System.Text.RegularExpressions.Regex
Abgeleitete Klassen
Threadsicherheit
Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.
Plattformen
Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition
.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.
Versionsinformationen
.NET Framework
Unterstützt in: 2.0, 1.1, 1.0
.NET Compact Framework
Unterstützt in: 2.0, 1.0
Siehe auch
Referenz
Regex-Member
System.Text.RegularExpressions-Namespace
Weitere Ressourcen
Reguläre Ausdrücke von .NET Framework
Sprachelemente für reguläre Ausdrücke