Diese Dokumentation wurde archiviert und wird nicht länger gepflegt.

Regex-Klasse

Aktualisiert: November 2007

Stellt einen unveränderlichen regulären Ausdruck dar.

Namespace:  System.Text.RegularExpressions
Assembly:  System (in System.dll)

[SerializableAttribute]
public class Regex : ISerializable
/** @attribute SerializableAttribute */ 
public class Regex implements ISerializable
public class Regex implements ISerializable

Die Regex-Klasse enthält mehrere static-Methoden (oder Shared in Visual Basic), mit deren Hilfe Sie einen regulären Ausdruck verwenden können, ohne dabei ausdrücklich ein Regex-Objekt erstellen zu müssen. In .NET Framework, Version 2.0, werden durch Aufrufe von statischen Methoden kompilierte reguläre Ausdrücke zwischengespeichert. Reguläre Ausdrücke, die durch Aufrufe von Instanzenmethoden kompiliert werden, werden hingegen nicht zwischengespeichert. Standardmäßig werden vom Modul für reguläre Ausdrücke die 15 zuletzt verwendeten statischen regulären Ausdrücke zwischengespeichert. Folglich sollten Sie in Anwendungen, die in großem Umfang auf eine festen Satz regulärer Ausdrücke zum Extrahieren, Ändern oder Überprüfen von Texten angewiesen sind, vorzugsweise diese statischen Methoden und nicht die entsprechenden Instanzenmethoden aufrufen. Es sind statische Überladungen der Methoden IsMatch, Match, Matches, Replace und Split verfügbar.

6f7hht7k.alert_note(de-de,VS.90).gifHinweis:

 Wenn die Standardcachegröße mit 15 statischen regulären Ausdrücken für Ihre Anwendung nicht geeignet ist, können Sie sie erhöhen, indem Sie den Wert der CacheSize-Eigenschaft ändern.

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", 
  	                     ".34", "0.34", "1,052.21"};
  	    
  	   // 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);
  	      }
  	   }
   }	
}
// The example displays the following output to the console:
//       -42 is a currency value.
//       19.99 is a currency value.
//       0.001 is not a currency value.
//       100 USD is not a currency value.
//       .34 is not a currency value.
//       0.34 is a currency value.
//       1,052.21 is not a currency value.


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 in:\n   {1}", 
                          matches.Count, 
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",  
                              groups["word"].Value, 
                              groups[0].Index, 
                              groups[1].Index);
        }

    }
	
}
// The example produces the following output to the console:
//       3 matches found in:
//          The the quick brown fox  fox jumped over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 50 and 54


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


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.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile für Smartphone, Windows Mobile für Pocket PC, Xbox 360

.NET Framework und .NET Compact Framework unterstützen nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

.NET Framework

Unterstützt in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 3.5, 2.0, 1.0

XNA Framework

Unterstützt in: 2.0, 1.0
Anzeigen: