高手详解C#编程中的规矩表达式（简述c#代码的书写规则）-编程开发-知优网

在这篇文章中，我将简要地介绍System.Text.RegularExpression中的类和方法、一些字符串匹配和替换的例子以及组结构的详细情况，最后，还会介绍一些你可能会用到的常见的表达式。

修正引荐《C#有用根底教程》

多少年来，许多的编程语言和东西都包括对规矩表达式的支撑，.NET根底类库中包括有一个姓名空间和一系列可以充分发挥规矩表达式威力的类，并且它们也都与未来的Perl 5中的规矩表达式兼容。

此外，regexp类还可以完结一些其他的功用，例如从右至左的结合形式和表达式的修正等。

应该把握的根底常识

规矩表达式的常识或许是不少编程人员“常学常忘”的常识之一。在这篇文章中，咱们将假定你现已把握了规矩表达式的用法，尤其是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 
{ 
Group g = m.Group(gnums[i]); 
//获得这次匹配的组 
Console.WriteLine("Group"+gnums[i]+"=["+g.ToString()+"]"); 
//核算这个组的开端方位和长度 
CaptureCollection cc = g.Captures; 
for (int j = 0; 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 = @" 
first tag text 
next tag text 
"; 
string p18 = @"]*?HREF\s*=\s*[""']?" + @"([^'"" >]+?)[ '""]?>"; 
MatchCollection mc18 = Regex.Matches(t18, p18, "si");