規則表達式的知識可能是不少編程人員“常學常忘”的知識之一。在這篇文章中，我們將假定你已經掌握了規則表達式的用法，尤其是perl 5中表達式的用法。.net的regexp類是perl 5中表達式的一個超集，因此，從理論上說它將作為一個很好的起點。我們還假設你具有了c#的語法和.net架構的基本知識。
  
　　如果你沒有規則表達式方面的知識，我建議你從perl 5的語法著手開始學習。在規則表達式方面的權威書籍是由杰弗里·弗雷德爾編寫的《掌握表達式》一書，對于希望深刻理解表達式的讀者，我們強烈建議閱讀這本書。
  
regularexpression組合體

　　regexp規則類包含在system.text.regularexpressions.dll文件中，在對應用軟件進行編譯時你必須引用這個文件，例如：

csc r:system.text.regularexpressions.dll foo.cs

命令將創建foo.exe文件，它就引用了system.text.regularexpressions文件。
  
名字空間簡介

　　在名字空間中僅僅包含著6個類和一個定義，它們是：
  
　　capture: 包含一次匹配的結果；
　　capturecollection: capture的序列；
　　group: 一次組記錄的結果，由capture繼承而來；
　　match: 一次表達式的匹配結果，由group繼承而來；
　　matchcollection: match的一個序列；
　　matchevaluator: 執行替換操作時使用的代理；
　　regex: 編譯后的表達式的實例。

　　regex類中還包含一些靜態的方法：

　　escape: 對字符串中的regex中的轉義符進行轉義；
　　ismatch: 如果表達式在字符串中匹配，該方法返回一個布爾值；
　　match: 返回match的實例；
　　matches: 返回一系列的match的方法；
　　replace: 用替換字符串替換匹配的表達式；
　　split: 返回一系列由表達式決定的字符串；
　　unescape:不對字符串中的轉義字符轉義。
  
簡單匹配

　　我們首先從使用regex、match類的簡單表達式開始學習。
  
match m = regex.match("abracadabra", "(a|b|r)+");
  
我們現在有了一個可以用于測試的match類的實例，例如：if (m.success)...
如果想使用匹配的字符串，可以把它轉換成一個字符串：
  
console.writeline("match="+m.tostring());
  
這個例子可以得到如下的輸出: match=abra。這就是匹配的字符串了。
  
字符串的替換

　　簡單字符串的替換非常直觀。例如下面的語句：
  
string s = regex.replace("abracadabra", "abra", "zzzz");
  
它返回字符串zzzzcadzzzz，所有匹配的字符串都被替換成了zzzzz。

　　現在我們來看一個比較復雜的字符串替換的例子：
  
string s = regex.replace(" abra ", @"^/s*(.*?)/s*$", "$1");
  
這個語句返回字符串abra，其前導和后綴的空格都去掉了。
  
　　上面的模式對于刪除任意字符串中的前導和后續空格都非常有用。在c#中，我們還經常使用字母字符串，在一個字母字符串中，編譯程序不把字符“ /” 作為轉義字符處理。在使用字符“/”指定轉義字符時，@"..."是非常有用的。另外值得一提的是$1在字符串替換方面的使用，它表明替換字符串只能包含被替換的字符串。
  
匹配引擎的細節

　　現在，我們通過一個組結構來理解一個稍微復雜的例子。看下面的例子：
  
string text = "abracadabra1abracadabra2abracadabra3";
  
  　　string pat = @"
  
  　　　　( # 第一個組的開始
  
  　　　　 abra # 匹配字符串abra
  
  　　　　 ( # 第二個組的開始
  
  　　　　 cad # 匹配字符串cad
  
  　　　　 )? # 第二個組結束（可選）
  
  　　　　) # 第一個組結束
  
  　　　　+ # 匹配一次或多次
  
  　　　　";
  
  　　//利用x修飾符忽略注釋
  
  　　regex r = new regex(pat, "x");
  
  　　//獲得組號碼的清單
  
  　　int[] gnums = r.getgroupnumbers();
  
  　　//首次匹配
  
  　　match m = r.match(text);
  
  　　while (m.success)
  
  　　 {
  
  　　//從組1開始
  
  　　 for (int i = 1; i < gnums.length; i++)
  
  　　　　{
  
  　　　　group g = m.group(gnums[i]);
  
  　　//獲得這次匹配的組
  
  　　　　console.writeline("group"+gnums[i]+"=["+g.tostring()+"]");
  
  　　//計算這個組的起始位置和長度
  
  　　　　capturecollection cc = g.captures;
  
  　　　　for (int j = 0; j < cc.count; j++)
  
  　　　　 {
  
  　　　　 capture c = cc[j];
  
  　　　　 console.writeline(" capture" + j + "=["+c.tostring()
  
  　　　　　　 + "] index=" + c.index + " length=" + c.length);
  
  　　　　 }
  
  　　　　}
  
  　　//下一個匹配
  
  　　 m = m.nextmatch();
  
  　　 }
  
 這個例子的輸出如下所示：
　　　　　
  　　group1=[abra]
  
  　　　　　　capture0=[abracad] index=0 length=7
  
  　　　　　　capture1=[abra] index=7 length=4
  
  　　group2=[cad]
  
  　　　　　　capture0=[cad] index=4 length=3
  
  　　group1=[abra]
  
  　　　　　　capture0=[abracad] index=12 length=7
  
  　　　　　　capture1=[abra] index=19 length=4
  
  　　group2=[cad]
  
  　　　　　　capture0=[cad] index=16 length=3
  
  　　group1=[abra]
  
  　　　　　　capture0=[abracad] index=24 length=7
  
  　　　　　　capture1=[abra] index=31 length=4
  
  　　group2=[cad]
  
  　　　　　　capture0=[cad] index=28 length=3

　　我們首先從考查字符串pat開始，pat中包含有表達式。第一個capture是從第一個圓括號開始的，然后表達式將匹配到一個abra。第二個capture組從第二個圓括號開始，但第一個capture組還沒有結束，這意味著第一個組匹配的結果是abracad ，而第二個組的匹配結果僅僅是cad。因此如果通過使用？符號而使cad成為一項可選的匹配，匹配的結果就可能是abra或abracad。然后，第一個組就會結束，通過指定+符號要求表達式進行多次匹配。
  
　　現在我們來看看匹配過程中發生的情況。首先，通過調用regex的 constructor方法建立表達式的一個實例，并在其中指定各種選項。在這個例子中，由于在表達式中有注釋，因此選用了x選項，另外還使用了一些空格。打開x選項，表達式將會忽略注釋和其中沒有轉義的空格。
  
　　然后，取得表達式中定義的組的編號的清單。你當然可以顯性地使用這些編號，在這里使用的是編程的方法。如果使用了命名的組，作為一種建立快速索引的途徑這種方法也十分有效。
  
　　接下來是完成第一次匹配。通過一個循環測試當前的匹配是否成功，接下來是從group 1開始重復對組清單執行這一操作。在這個例子中沒有使用group 0的原因是group 0是一個完全匹配的字符串，如果要通過收集全部匹配的字符串作為一個單一的字符串，就會用到group 0了。
  
　　我們跟蹤每個group中的capturecollection。通常情況下每次匹配、每個group中只能有一個capture，但本例中的group1則有兩個 capture：capture0和capture1。如果你僅需要group1的tostring，就會只得到abra，當然它也會與abracad匹配。組中tostring的值就是其capturecollection中最后一個capture的值，這正是我們所需要的。如果你希望整個過程在匹配 abra后結束，就應該從表達式中刪除+符號，讓regex引擎知道我們只需要對表達式進行匹配。
  
基于過程和基于表達式方法的比較

　　一般情況下，使用規則表達式的用戶可以分為以下二大類：第一類用戶盡量不使用規則表達式，而是使用過程來執行一些需要重復的操作；第二類用戶則充分利用規則表達式處理引擎的功能和威力，而盡可能少地使用過程。
  
　　對于我們大多數用戶而言，最好的方案莫過于二者兼而用之了。我希望這篇文章能夠說明.net語言中regexp類的作用以及它在性能和復雜性之間的優、劣點。
  
基于過程的模式

　　我們在編程中經常需要用到的一個功能是對字符串中的一部分進行匹配或其他一些對字符串處理，下面是一個對字符串中的單詞進行匹配的例子：

string text = "the quick red fox jumped over the lazy brown dog.";
  
  　　system.console.writeline("text=[" + text + "]");
  
  　　string result = "";
  
  　　string pattern = @"/w+|/w+";
  
  　　foreach (match m in regex.matches(text, pattern))
  
  　　 {
  
  　　// 取得匹配的字符串
  
  　　 string x = m.tostring();
  
  　　// 如果第一個字符是小寫
  
  　　 if (char.islower(x[0]))
  
  　　// 變成大寫
  
  　　　　x = char.toupper(x[0]) + x.substring(1, x.length-1);
  
  　　// 收集所有的字符
  
  　　 result += x;
  
  　　 }
  
  　　system.console.writeline("result=[" + result + "]");
  
 　　正象上面的例子所示，我們使用了c#語言中的foreach語句處理每個匹配的字符，并完成相應的處理，在這個例子中，新創建了一個result字符串。這個例子的輸出所下所示：
  
　　text=[the quick red fox jumped over the lazy brown dog.]
  
　　result=[the quick red fox jumped over the lazy brown dog.]
  
基于表達式的模式

　　完成上例中的功能的另一條途徑是通過一個matchevaluator，新的代碼如下所示：
  
static string captext(match m)
  
  　　　　{
  
  　　//取得匹配的字符串
  
  　　　　string x = m.tostring();
  
  　　// 如果第一個字符是小寫
  
  　　　　if (char.islower(x[0]))
  
  　　// 轉換為大寫
  
  　　　　 return char.toupper(x[0]) + x.substring(1, x.length-1);
  
  　　　　return x;
  
  　　　　}
  
  　　　　
  
  　　 static void main()
  
  　　　　{
  
  　　　　string text = "the quick red fox jumped over the
  
  　　　　 lazy brown dog.";
  
  　　　　system.console.writeline("text=[" + text + "]");
  
  　　　　string pattern = @"/w+";
  
  　　　　string result = regex.replace(text, pattern,
  
  　　 new matchevaluator(test.captext));
  
  　　　　system.console.writeline("result=[" + result + "]");
  
  　　　　}
  
　　同時需要注意的是，由于僅僅需要對單詞進行修改而無需對非單詞進行修改，這個模式顯得非常簡單。

常用表達式

　　為了能夠更好地理解如何在c#環境中使用規則表達式，我寫出一些對你來說可能有用的規則表達式，這些表達式在其他的環境中都被使用過，希望能夠對你有所幫助。
  
羅馬數字

string p1 = "^m*(d?c{0,3}|c[dm])" + "(l?x{0,3}|x[lc])(v?i{0,3}|i[vx])$";
  
  　　string t1 = "vii";
  
  　　match m1 = regex.match(t1, p1);
  
交換前二個單詞

string t2 = "the quick brown fox";
  
  　　string p2 = @"(/s+)(/s+)(/s+)";
  
  　　regex x2 = new regex(p2);
  
  　　string r2 = x2.replace(t2, "$3$2$1", 1);
  
關健字=值

string t3 = "myval = 3";
  
  　　string p3 = @"(/w+)/s*=/s*(.*)/s*$";
  
  　　match m3 = regex.match(t3, p3);
  
實現每行80個字符

string t4 = "********************"
  
  　　 + "******************************"
  
  　　 + "******************************";
  
  　　string p4 = ".{80,}";
  
  　　match m4 = regex.match(t4, p4);
  
月/日/年 小時:分:秒的時間格式

string t5 = "01/01/01 16:10:01";
  
  　　string p5 = @"(/d+)/(/d+)/(/d+) (/d+):(/d+):(/d+)";
  
  　　match m5 = regex.match(t5, p5);
  
改變目錄（僅適用于windows平臺）

string t6 = @"c:/documents and settings/user1/desktop/";
  
  string r6 = regex.replace(t6,@"//user1//", @"//user2//");
  
擴展16位轉義符

string t7 = "%41"; // capital a
  
  　　string p7 = "%([0-9a-fa-f][0-9a-fa-f])";
  
  　　string r7 = regex.replace(t7, p7, hexconvert);
  
刪除c語言中的注釋（有待完善）

string t8 = @"
  
  　　/*
  
  　　 * 傳統風格的注釋
  
  　　 */
  
  　　";
  
  　　string p8 = @"
  
  　　 //* # 匹配注釋開始的定界符
  
  　　 .*? # 匹配注釋
  
  　　 /*/ # 匹配注釋結束定界符
  
  　　";
  
  　　string r8 = regex.replace(t8, p8, "", "xs");
  
刪除字符串中開始和結束處的空格

string t9a = " leading";
  
  　　string p9a = @"^/s+";
  
  　　string r9a = regex.replace(t9a, p9a, "");
  
  　　string t9b = "trailing ";
  
  　　string p9b = @"/s+$";
  
  　　string r9b = regex.replace(t9b, p9b, "");
  
在字符/后添加字符n，使之成為真正的新行

string t10 = @"/ntest/n";
  
  　　string r10 = regex.replace(t10, @"//n", "/n");
  
轉換ip地址

string t11 = "55.54.53.52";
  
  　　string p11 = "^" +
  
  　　 @"([01]?/d/d|2[0-4]/d|25[0-5])/." +
  
  　　 @"([01]?/d/d|2[0-4]/d|25[0-5])/." +
  
  　　 @"([01]?/d/d|2[0-4]/d|25[0-5])/." +
  
  　　 @"([01]?/d/d|2[0-4]/d|25[0-5])" +
  
  　　 "$";
  
  　　match m11 = regex.match(t11, p11);
  
刪除文件名包含的路徑

string t12 = @"c:/file.txt";
  
  　　string p12 = @"^.*//";
  
  　　string r12 = regex.replace(t12, p12, "");
  
聯接多行字符串中的行

string t13 = @"this is
  
  　　a split line";
  
  　　string p13 = @"/s*/r?/n/s*";
  
  　　string r13 = regex.replace(t13, p13, " ");
  
提取字符串中的所有數字

string t14 = @"
  
  　　test 1
  
  　　test 2.3
  
  　　test 47
  
  　　";
  
  　　string p14 = @"(/d+/.?/d*|/./d+)";
  
  　　matchcollection mc14 = regex.matches(t14, p14);
  
找出所有的大寫字母

string t15 = "this is a test of all caps";
  
  　　string p15 = @"(/b[^/wa-z0-9_]+/b)";
  
  　　matchcollection mc15 = regex.matches(t15, p15);
  
找出小寫的單詞

string t16 = "this is a test of lowercase";
  
  　　string p16 = @"(/b[^/wa-z0-9_]+/b)";
  
  　　matchcollection mc16 = regex.matches(t16, p16);
  
找出第一個字母為大寫的單詞

string t17 = "this is a test of initial caps";
  
  　　string p17 = @"(/b[^/wa-z0-9_][^/wa-z0-9_]*/b)";
  
  　　matchcollection mc17 = regex.matches(t17, p17);
  
找出簡單的html語言中的鏈接

string t18 = @"
  
  　　<html>
  
  　　<a href=""first.htm"">first tag text</a>
  
  　　<a href=""next.htm"">next tag text</a>
  
  　　</html>
  
  　　";
  
  　　string p18 = @"<a[^>]*?href/s*=/s*[""']?" + @"([^'"" >]+?)[ '""]?>";
  
  　　matchcollection mc18 = regex.matches(t18, p18, "si");