Die Anleitung zu C# Reguläre Ausdrücke

1- Die reguläre Ausdrücke (Regular expression)

1.1- Die Überblick

Eine reguläre Ausdruck (Regular expressions) definiert eine Vorlage (pattern) zur Suche des String. Sie kann zur Suche, Bearbeitung und Änderung der Text benutzt. Die durch die reguläre Ausdruck definierte Ausdruck kann die vorher gegebene Text einmal, zweimail oder niemal entsprechen.

Die Abkürzung von der regulären Ausdruck ist regex

1.2- Die Sprachen unterstützen

Die regulären Ausdrücke (Regular expression) werden durch die meisten Programmiersprache wie   C#, Java, Perl, Groovy, v..v... unterstützt. Leider unterstützt jede Sprache die regulären Ausdrücke unterschiedlich

2- Die Regelung zum Schreiben des regulären Ausdrücke

No Regular Expression Die Bezeichnung
1 . Einem oder mehren Zeichen passen (match) 
2 ^regex Die reguläre Ausdrücke muss am Anfang passen
3 regex$ Die reguläre Ausdrücke muss Ende der Zeile passen
4 [abc] Die Definition festlegen, kann a oder b oder c passen.
5 [abc][vz] Die Definition festlegen, kann a oder b oder c danach v oder z passen 
6 [^abc] Wenn das Zeichen ^ als den ersten Charakter in die Anführungzeichen [  ] auftritt, verneint es das Modell. Das kann irgendein Zeichen außer a oder b oder c entprechen 
7 [a-d1-7] Der Raum: ein String zwischen a und d und die Zahl vom 1 bis 7 anmessen
8 X|Z X oder Z finden.
9 XZ X finden und danach Z.
10 $ Prüfung des Ende der Zeile.

11 \d Irgendeine Zahl, die Abkürzung von [0-9]
12 \D Das Zeichen ist kein Zahl, die Abkürzung von  [^0-9]
13 \s Das Leerzeichen, die Abkürzung von [ \t\n\x0b\r\f]
14 \S Das Zeichen ist kein Leerzeichen, die Abkürzung von  [^\s]
15 \w Das Buchstabe Zeichen, die Abkürzung von [a-zA-Z_0-9]
16 \W Das Nicht-Buchstabe Zeichen, die Abkürzung von [^\w]
17 \S+ Einige Zeichen ist kein Leerzeichen (ein oder viel)
18 \b Das Zeichen gehört zu a-z oder A-Z oder 0-9 oder _, die Abkürzung von [a-zA-Z0-9_].

19 * 0 oder mehrmals auftreten, die Abkürzung von {0,}
20 + einmal oder mehrmals, die Abkürzung von  {1,}
21 ? 0 oder einmal auftreten, ? ist Abkürzung von {0,1}.
22 {X} X mals auftreten, {}
23 {X,Y} im Raum vom X bis Y mals auftreten
24 *? * heißt die Auftretung 0 oder mehrmals, das Einfügung von Zeichen ? hinten heißt die Suche nach der kleinste Zusammenpassung

3- Die besonderen Zeichen im C# Regex (Special characters)

Einige besonderen Zeichen im  C# Regex:
\.[{(*+?^$|
 
Die Zeichen oben sind besonder. Im C# Regex wenn Sie sie als die normalen Zeichen verstehen möchten, sollen Sie die Zeichen \ vor ihnen stellen.

Zum Beispiel das Zeichen von der Punkt (.) versteht  C# Regex ein oder mehre Zeichen. Wenn Sie sie als die normale Punkt verstehen, brauchen Sie das Zeichen \ vor ihr stellen .
// Das regex bezeichnet eine oder mehrer Zeichen .
string regex = ".";

// Das regex bezeichnet das Zeichen von der Punkt.
string regex = "\\.";
string regex = @"\.";

4- Die Benutzung von Regex.IsMatch(string)

  • Regex class
...
// Prüfen, ob alle String dem regex entsprechen oder nicht
public bool IsMatch(string regex)
..
Die Verwendung der Methode   Regex.IsMatch(string regex) erlaubt Sie zu prüfen, ob ein String dem regex entspricht oder nicht. Das ist die meist übliche Maßnahme. Sehen Sie die Beispiele:

Regex .

In regulären Ausdrücke vom C# ist das Zeichen (.) besonder. Es vertritt ein oder mehre Zeichen. Wenn Sie  möchten, C# versteht es als normal, sollen Sie "\\." oder @"\." schreiben brauchen;
DotExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

namespace RegularExpressionTutorial
{
    class DotExample
    {
        public static void Main(string[] args)
        {
            // Das String mit 0 Zeichen  (leer)          
            string s1 = "";
            Console.WriteLine("s1=" + s1);

            // Prüfen, ob das String s1 ein oder mehrer Zeichen entsprechen.
            // Die Regelung .
            // ==> False (falsch)
            bool match = Regex.IsMatch(s1, ".");
            Console.WriteLine("  -Match . " + match);

            // Das String mit einem Zeichen.  
            string s2 = "a";
            Console.WriteLine("s2=" + s2);

            // Prüfen, ob das String s2 ein oder mehrer Zeichen entsprechen.
            // Die Regelung .
            // ==> true (richtig)
            match = Regex.IsMatch(s2, ".");
            Console.WriteLine("  -Match . " + match);

            // Das String mit 3 Zeichen
            string s3 = "abc";
            Console.WriteLine("s3=" + s3);

            // Prüfen, ob das String s3 ein oder mehrer Zeichen entsprechen.
            // Die Regelung .
            // ==> true (richtig)
            match = Regex.IsMatch(s3, ".");
            Console.WriteLine("  -Match . " + match);

            // Das String mit 3 Zeichen
            string s4 = "abc";
            Console.WriteLine("s4=" + s4);

            // Prüfen, ob das String s4 ein oder mehrer Zeichen entsprechen.
            // Die Regelung .
            // ==> false (falsch)
            match = Regex.IsMatch(s4, @"\.");
            Console.WriteLine("  -Match \\. " + match);

            // Das String mit einem Zeichen (die Punkt).
            string s5 = ".";
            Console.WriteLine("s5=" + s5);

            // Prüfen, ob das String s5 ein oder mehrer Zeichen entsprechen.
            // Die Regelung .
            // ==> true (richtig)
            match = Regex.IsMatch(s5, @"\.");
            Console.WriteLine("  -Match \\. " + match);

            Console.Read();
        }
    }

}
Das Beispiel durchführen
Ein anderes Beispiel über Regex.IsMath(string):
RegexIsMatchExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

namespace RegularExpressionTutorial
{
    class RegexIsMatchExample
    {
        public static void Main(string[] args)
        {
            // Das String hat ein Zeichen
            string s2 = "m";
            Console.WriteLine("s2=" + s2);

            // s2 prüfen
            // Mit dem Zeichen 'm' beginnen
            // Der Regel ^
            // ==> true
            bool match = Regex.IsMatch(s2, "^m");
            Console.WriteLine("  -Match ^m " + match);

            // Das String hat 7 Zeichen
            string s3 = "MMnnnnn";
            Console.WriteLine("s3=" + s3);

            // s3 prüfen
            // Mit MM beginnen
            // Der Regel ^
            // ==> true
            match = Regex.IsMatch(s3, "^MM");
            Console.WriteLine("  -Match ^MM " + match);

            // s3 prüfen
            // Mit MM beginnen
            // Danach tritt das Zeichen 'n' einmal oder mehrmals auf
            // Der Regel ^ und +
            match = Regex.IsMatch(s3, "^MMn+");
            Console.WriteLine("  -Match ^MMn+ " + match);

            // Das String mit einem Zeichen
            String s4 = "p";
            Console.WriteLine("s4=" + s4);

            // s4, durch 'p' endet, prüfen
            // Der Regel $
            // ==> true
            match = Regex.IsMatch(s4, "p$");
            Console.WriteLine("  -Match p$ " + match);

            // Das String hat 6 Zeichen
            string s5 = "122nnp";
            Console.WriteLine("s5=" + s5);


            // Prüfen s5 endet mit 'p'
            // ==> true
            match = Regex.IsMatch(s5, "p$");
            Console.WriteLine("  -Match p$ " + match);

            // s5 prüfen
            // Mit einem oder mehren Zeichen beginnen (der Regel)
            // Danach kommt das Zeichen 'n', tritt 1 bis 3 mals auf (der Regel n{1,3} )
            // Mit dem Zeichen'p' enden (Der Regel $)
            // Mit der Regelung ., {x,y}, $ verbinden
            // ==> true
            match = Regex.IsMatch(s5, ".n{1,3}p$");
            Console.WriteLine("  -Match .n{1,3}p$ " + match);


            String s6 = "2ybcd";
            Console.WriteLine("s6=" + s6);

            // s6 prüfen
            // Mit '2' beginnen
            // Danach kommt 'x' oder 'y' oder 'z'  (der Regel [xyz])
            // Danach tritt irgendein Zeichen 0 oder mehrmals auf (der Regel *)
            match = Regex.IsMatch(s6, "2[xyz].*");

            Console.WriteLine("  -Match 2[xyz].* " + match);

            string s7 = "2bkbv";
            Console.WriteLine("s7=" + s7);

            // s7 prüfen, mit irgendeinem Zeichen beginnen (ein oder mehrmals)
            // Danach kommt 'a' oder 'b' oder 'c' (der Regel [abc] )
            // Danach kommt 'z' oder 'v' (der Regel [zv] )
            // Zuletzt ist irgendein Zeichen, 0 oder mehrmals (der Regel .*)
            // ==> true
            match = Regex.IsMatch(s7, ".[abc][zv].*");

            Console.WriteLine("  -Match .[abc][zv].* " + match);


            Console.Read();
        }
    }


}
Das Ergebnis der Beispieldurchführung
Das nächste Beispiel
RegexIsMatchExample2.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

namespace RegularExpressionTutorial
{
    class RegexIsMatchExample2
    {
        public static void Main(string[] args)
        {
            String s = "The film Tom and Jerry!";

            // String s checken
            // Mit einem Zeichen beginnen, 0 oder mehrmals auftreten (der Regel  .*)
            // Zum nächsten ist das "Tom" oder "Jerry"
            // Mit einem Zeichen enden, 1 oder mehrmals auftreten (der Regel .)
            // Mit dem Regel : ., *, X|Z verbinden
            bool match = Regex.IsMatch(s, ".*(Tom|Jerry).");
            Console.WriteLine("s=" + s);
            Console.WriteLine("-Match .*(Tom|Jerry). " + match);

            s = "The cat";
            // ==> false
            match = Regex.IsMatch(s, ".*(Tom|Jerry).");
            Console.WriteLine("s=" + s);
            Console.WriteLine("-Match .*(Tom|Jerry). " + match);

            s = "The Tom cat";
            // ==> true
            match = Regex.IsMatch(s, ".*(Tom|Jerry).");
            Console.WriteLine("s=" + s);
            Console.WriteLine("-Match .*(Tom|Jerry). " + match);

            Console.Read();
        }
    }

}
Das Ergebnis der Beispielsdurchführung

5- Using Regex.Split & Regex.Replace

Eine der nutzlichen Methode ist Regex.Split(string,string), diese Methode trennt ein String in vielen Substring. Zum Beispiel haben Sie das String "One,Two,Three" und Sie möchten in 3 Substring teilen und durch das Komma trennen
SplitWithRegexExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

namespace RegularExpressionTutorial
{
    class SplitWithRegexExample
    {
        public static void Main(string[] args)
        {
            // \t: Das Zeichen TAB
            // \n: Das NewLine character.
            string TEXT = "This \t\t is \n my \t text";

            Console.WriteLine("TEXT=" + TEXT);

            // Die Definition eines  Regex:
            // Das Leerzeichen tritt einmal oder vielmal ein.
            // Die Leerzeichen sind: \t\n\x0b\r\f
            // Die Verbindung mit dem Regel: \s và +
            String regex = @"\s+";

            Console.WriteLine(" -------------- ");

            String[] splitString = Regex.Split(TEXT, regex);

             
            Console.WriteLine(splitString.Length); // ==> 4

            foreach (string str in splitString)
            {
                Console.WriteLine(str);
            }

            Console.WriteLine(" -------------- ");

            // Alle Leerzeichen durch Zeichen Tab ersetzen
            String newText = Regex.Replace(TEXT, "\\s+", "\t");
            Console.WriteLine("New text=" + newText);

            Console.Read();
        }
    }

}
Das Beispiel durchführen

6- MatchCollection & Match verwenden

Verwenden Sie die Methode  Regex.Matches(...) um die Substring eines String zu finden, das einer regulären Ausdruck entspricht. Die Methode gibt eine Objekt MatchCollection zurück.
** Regex.Matches() **
public MatchCollection Matches(
    string input
)

public MatchCollection Matches(
    string input,
    int startat
)

public static MatchCollection Matches(
    string input,
    string pattern
)

public static MatchCollection Matches(
    string input,
    string pattern,
    RegexOptions options,
    TimeSpan matchTimeout
)

public static MatchCollection Matches(
    string input,
    string pattern,
    RegexOptions options
)
Das folgende Beispiel macht ein String in vielen Substring und durch das Leerzeichen (whitespace) trennen.
MatchCollectionExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

namespace RegularExpressionTutorial
{
    class MatchCollectionExample
    {
        public static void Main(string[] args)
        {

            string TEXT = "This \t is a \t\t\t String";

            // \w : Das Buchstabe Zeichen, die Abkürzung von  [a-zA-Z_0-9]
            // \w+ : Das Buchstabe Zeichen, ein oder viel Mal eintreten
            string regex = @"\w+";


            MatchCollection matchColl = Regex.Matches(TEXT, regex);

            foreach (Match match in matchColl)
            {
                Console.WriteLine(" ---------------- ");
                Console.WriteLine("Value: " + match.Value);
                Console.WriteLine("Index: " + match.Index);
                Console.WriteLine("Length: " + match.Length);
            }


            Console.Read();
        }
    }

}
Das Ergebnis durchführen

7- Die Gruppe (Group)

Eine reguläre Ausdruck können Sie in viele Gruppe trennen (group):
// Eine reguläre Ausdrucke
string regex = @"\s+=\d+";

// In 3 Gruppen durch ( ) schreiben
string regex2 = @"(\s+)(=)(\d+)";

// 2 Gruppe (group)
string regex3 = @"(\s+)(=\d+)";
Die Gruppe group können miteinandere einnisten. Deshalb brauchen ein Regel zur Indexierung der   group. Alle pattern werden die Gruppe 0 definiert. Und die restliche werden wie folgend definiert:

Achtung: Verwenden Sie (?:pattern) um C# zu informieren, das ist eine group (None-capturing group)

Sie können eine Gruppe mit dem Name   (?<groupName>pattern) oder  (?'groupName'pattern) definieren und Sie können die angemessene Inhalt mit  match.Groups["groupName"] zugreifen. Das mach Regex länger aber die Code ist mehr verständlich und leicht.

Die Gruppe kann durch   match.Groups[groupIndex] mit der ähnlichen Indexierungsregelung zugriffen werden
-
Sehen Sie das Beispiel zur Verwendung der Gruppe, die den Name gestellt werden
NamedGroupExample.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

namespace RegularExpressionTutorial
{
    class NamedGroupExample
    {
        public static void Main(string[] args)
        {
            string TEXT = " int a = 100;  float b= 130;  float c= 110 ; ";

            // Verwenden Sie  (?<groupName>pattern) 
            // um eine Gruppe mit dem Name : groupName zu definieren
            // Die Definition einer Gruppe mit dem Name 'declare': benutzen (?<declare> ...)
            // Und einer Gruppe mit dem Name  'value': benutzen (?<value> ..)
            string regex = @"(?<declare>\s*(int|float)\s+[a-z]\s*)=(?<value>\s*\d+\s*);";

            MatchCollection matchCollection = Regex.Matches(TEXT, regex);


            foreach (Match match in matchCollection)
            {
                string group = match.Groups["declare"].Value;
                Console.WriteLine("Full Text: " + match.Value);
                Console.WriteLine("<declare>: " + match.Groups["declare"].Value);
                Console.WriteLine("<value>: " + match.Groups["value"].Value);
                Console.WriteLine("------------------------------");
            }

            Console.Read();
        }
    }

}
Das Ergebnis der Beispielsdurchführung
Um leicht zu verstehen, können Sie das folgende Beispiel anschauen

8- MatchCollection, Group und *? benutzen

Falls   *? sehr wichtig, schauen Sie das folgende Beispiel an:
// Das ist ein regex
// Das irgendeine Zeiche, 0 oder mehrmals auftreten,
// danach kommt das Zeichen ' und dann  >
string regex = ".*'>";

// Das String TEXT1 folgend entspricht dem obengemeinten regex.
string TEXT1 = "FILE1'>";

// Das String TEXT2 entspricht das obengemeinten regex
string TEXT2 = "FILE1'> <a href='http://HOST/file/FILE2'>";
*? wird eine kleinste Zusammenpassung (smallest match) finden. Wir sehen das folgende Beispiel:
NamedGroupExample2.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Text.RegularExpressions;

namespace RegularExpressionTutorial
{
    class NamedGroupExample2
    {
        public static void Main(string[] args)
        {

            string TEXT = "<a href='http://HOST/file/FILE1'>File 1</a>"
                         + "<a href='http://HOST/file/FILE2'>File 2</a>";

            // Eine Gruppe mit dem Name fileName definieren.
            // * bedeutet 0 oder mehrmals auftreten.
            // *? bedeutet die kleinste Zusammenpassung  (smallest match).
            string regex = "/file/(?<fileName>.*?)'>";

            MatchCollection matchCollection = Regex.Matches(TEXT, regex);


            foreach (Match match in matchCollection)
            {
                Console.WriteLine("File Name = " + match.Groups["fileName"].Value);
                Console.WriteLine("------------------------------");
            }

            Console.Read();
        }
    }

}
Das Ergebnis der Beispielsdurchführung

View more categories: