到目前为止，许多的编程语言和工具都包含对正则表达式的支持，当然.NET也不例外，.NET基础类库中包含有一个名称空间和一系列可以充分发挥规则表达式威力的类。
正则表达式的知识可能是不少编程人员最烦恼的事儿了。如果你还没有规则表达式方面的知识的话，建议从正则表达式的基础知识入手。前参见正则表达式语法。
下面就来研究C#中的正则表达式，C#中的正则表达式包含在.NET基础雷库的一个名称空间下，这个名称空间就是System.Text.RegularExpressions。该名称空间包括8个类，1个枚举，1个委托。他们分别是：
Capture: 包含一次匹配的结果；
CaptureCollection: Capture的序列；
Group: 一次组记录的结果，由Capture继承而来；
GroupCollection：表示捕获组的集合
Match: 一次表达式的匹配结果，由Group继承而来；
MatchCollection: Match的一个序列；
MatchEvaluator: 执行替换操作时使用的委托；
Regex：编译后的表达式的实例。
RegexCompilationInfo：提供编译器用于将正则表达式编译为独立程序集的信息
RegexOptions 提供用于设置正则表达式的枚举值
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){}，如果想使用匹配的字符串，可以把它转换成一个字符串： MesaageBox.Show("Match="+m.ToString()); 这个例子可以得到如下的输出: Match=abra。这就是匹配的字符串了。
Regex 类表示只读正则表达式类。它还包含各种静态方法（在下面的实例中将逐一介绍），允许在不显式创建其他类的实例的情况下使用其他正则表达式类。
以下代码示例创建了 Regex 类的实例并在初始化对象时定义一个简单的正则表达式。声明一个Regex对象变量：Regex objAlphaPatt;，接着创建Regex对象的一个实例，并定义其规则：objAlphaPatt=new Regex("[^a-zA-Z]");
IsMatch方法指示 Regex 构造函数中指定的正则表达式在输入字符串中是否找到匹配项。这是我们使用C#正则表达式时最常用的方法之一。下面的例子说明了IsMatch方法的使用：
if( !objAlphaPatt.IsMatch("testisMatchMethod"))
lblMsg.Text = "匹配成功";
else
lblMsg.Text = "匹配不成功";
这段代码执行的结果是“匹配成功”
if( ! objAlphaPatt.IsMatch("testisMatchMethod7654298"))
lblMsg.Text = "匹配成功";
else
lblMsg.Text = "匹配不成功";
这段代码执行的结果是“匹配不成功”
Escape方法表示把转义字符作为字符本身使用，而不再具有转义作用，最小的元字符集（\、*、+、?、|、{、[、(、)、^、$、.、# 和空白）。Replace方法则是用指定的替换字符串替换由正则表达式定义的字符模式的所有匹配项。看下面的例子，还是使用上面定义的Regex对象：objAlphaPatt.Replace("this [test] ** replace and escape" ,Regex.Escape("()"));他的返回结果是：this\(\)\(\)test\(\)\(\)\(\)\(\)\(\)replace\(\)and\(\)escape，如果不是Escape的话，则返回结果是：this()()test()()()()()replace()and()escape，Unescape 反转由 Escape 执行的转换，但是，Escape 无法完全反转 Unescape。
Split方法是把由正则表达式匹配项定义的位置将输入字符串拆分为一个子字符串数组。例如：
Regex r = new Regex("-"); // Split on hyphens.
string[] s = r.Split("first-second-third");
for(int i=0;i<s.Length;i++)
{
Response.Write(s[i]+"<br>");
}
执行的结果是：
First
Second
Third
看上去和String的Split方法一样，但string的Split方法在由正则表达式而不是一组字符确定的分隔符处拆分字符串。
Match方法是在输入字符串中搜索正则表达式的匹配项，并Regex 类的 Match 方法返回 Match 对象，Match 类表示正则表达式匹配操作的结果。下面的例子演示Match方法的使用，并利用Match对象的Group属性返回Group对象：
string text = @"public string testMatchObj string s string match ";
string pat = @"(\w+)\s+(string)";
// Compile the regular expression.
Regex r = new Regex(pat, RegexOptions.IgnoreCase);
// Match the regular expression pattern against a text string.
Match m = r.Match(text);
int matchCount = 0;
while (m.Success)
{
Response.Write("Match"+ (++matchCount) + "<br>");
for (int i = 1; i <= 2; i++)
{
Group g = m.Groups[i];
Response.Write("Group"+i+"='" + g + "'" + "<br>");
CaptureCollection cc = g.Captures;
for (int j = 0; j < cc.Count; j++)
{
Capture c = cc[j];
Response.Write("Capture"+j+"='" + c + "', Position="+c.Index + "<br>");
}
}
m = m.NextMatch();
}
该事例运行结果是：
Match1
Group1='public'
Capture0='public', Position=0
Group2='string'
Capture0='string', Position=7
Match2
Group1='testMatchObj'
Capture0='testMatchObj', Position=14
Group2='string'
Capture0='string', Position=27
Match3
Group1='s'
Capture0='s', Position=34
Group2='string'
Capture0='string', Position=36
MatchCollection 类表示成功的非重叠匹配的只读的集合，MatchCollection 的实例是由 Regex.Matches 属性返回的，下面的实例说明了通过在输入字符串中找到所有与Regex中指定的匹配并填充 MatchCollection。
MatchCollection mc;
Regex r = new Regex("match");
mc = r.Matches("matchcollectionregexmatchs");
for (int i = 0; i < mc.Count; i++)
{
Response.Write( mc[i].Value + " POS:" + mc[i].Index.ToString() + "<br>");
}
该实例运行的结果是：
match POS:0
match POS:20
有一段时间，正则表达式学习很火热很潮流，当时在优快云一天就能看到好几个正则表达式的帖子，那段时间借助论坛以及Wrox Press出版的《C#字符串和正则表达式参考手册》学习了一些基础的知识，同时也为我在优快云大概赚了1000分，今天想起来，去找《C#字符串和正则表达式参考手册》时，已经不知所踪了。现在用到正则的时候也比较少，把以前的笔记等整理一下，以志不忘。
（1）“@”符号
符下两ows表研究室的火热，当晨在“@”虽然并非C#正则表达式的“成员”，但是它经常与C#正则表达式出双入对。“@”表示，跟在它后面的字符串是个“逐字字符串”，不是很好理解，举个例子，以下两个声明是等效的：
string x="D:\\My Huang\\My Doc";
string y = @"D:\My Huang\My Doc";
事实上，如果按如下声明，C#将会报错，因为“\”在C#中用于实现转义，如“\n”换行：
string x = "D:\My Huang\My Doc";
（2）基本的语法字符。
\d 0-9的数字
\D \d的补集（以所以字符为全集，下同），即所有非数字的字符
\w 单词字符，指大小写字母、0-9的数字、下划线
\W \w的补集
\s 空白字符，包括换行符\n、回车符\r、制表符\t、垂直制表符\v、换页符\f
\S \s的补集
. 除换行符\n外的任意字符
[…] 匹配[]内所列出的所有字符
[^…] 匹配非[]内所列出的字符
下面提供一些简单的示例：
stringi="\n";stringm="3";Regexr=newRegex(@"\D");//同Regexr=newRegex("\\D");//r.IsMatch(i)结果：true//r.IsMatch(m)结果：falsestringi="%";stringm="3";Regexr=newRegex("[a-z0-9]");//匹配小写字母或数字字符//r.IsMatch(i)结果：false//r.IsMatch(m)结果：true
（3）定位字符
“定位字符”所代表的是一个虚的字符，它代表一个位置，你也可以直观地认为“定位字符”所代表的是某个字符与字符间的那个微小间隙。
^ 表示其后的字符必须位于字符串的开始处
$ 表示其前面的字符必须位于字符串的结束处
\b 匹配一个单词的边界
\B 匹配一个非单词的边界
另外，还包括：\A 前面的字符必须位于字符处的开始处，\z 前面的字符必须位于字符串的结束处，\Z 前面的字符必须位于字符串的结束处，或者位于换行符前
下面提供一些简单的示例：
stringi="Livefornothing,dieforsomething";Regexr1=newRegex("^Livefornothing,dieforsomething$");//r1.IsMatch(i)trueRegexr2=newRegex("^Livefornothing,dieforsome$");//r2.IsMatch(i)falseRegexr3=newRegex("^Livefornothing,dieforsome");//r3.IsMatch(i)truestringi=@"Livefornothing,dieforsomething";//多行Regexr1=newRegex("^Livefornothing,dieforsomething$");Console.WriteLine("r1matchcount:"+r1.Matches(i).Count);//0Regexr2=newRegex("^Livefornothing,dieforsomething$",RegexOptions.Multiline);Console.WriteLine("r2matchcount:"+r2.Matches(i).Count);//0Regexr3=newRegex("^Livefornothing,\r\ndieforsomething$");Console.WriteLine("r3matchcount:"+r3.Matches(i).Count);//1Regexr4=newRegex("^Livefornothing,$");Console.WriteLine("r4matchcount:"+r4.Matches(i).Count);//0Regexr5=newRegex("^Livefornothing,$",RegexOptions.Multiline);Console.WriteLine("r5matchcount:"+r5.Matches(i).Count);//0Regexr6=newRegex("^Livefornothing,\r\n$");Console.WriteLine("r6matchcount:"+r6.Matches(i).Count);//0Regexr7=newRegex("^Livefornothing,\r\n$",RegexOptions.Multiline);Console.WriteLine("r7matchcount:"+r7.Matches(i).Count);//0Regexr8=newRegex("^Livefornothing,\r$");Console.WriteLine("r8matchcount:"+r8.Matches(i).Count);//0Regexr9=newRegex("^Livefornothing,\r$",RegexOptions.Multiline);Console.WriteLine("r9matchcount:"+r9.Matches(i).Count);//1Regexr10=newRegex("^dieforsomething$");Console.WriteLine("r10matchcount:"+r10.Matches(i).Count);//0Regexr11=newRegex("^dieforsomething$",RegexOptions.Multiline);Console.WriteLine("r11matchcount:"+r11.Matches(i).Count);//1Regexr12=newRegex("^");Console.WriteLine("r12matchcount:"+r12.Matches(i).Count);//1Regexr13=newRegex("$");Console.WriteLine("r13matchcount:"+r13.Matches(i).Count);//1Regexr14=newRegex("^",RegexOptions.Multiline);Console.WriteLine("r14matchcount:"+r14.Matches(i).Count);//2Regexr15=newRegex("$",RegexOptions.Multiline);Console.WriteLine("r15matchcount:"+r15.Matches(i).Count);//2Regexr16=newRegex("^Livefornothing,\r$\n^dieforsomething$",RegexOptions.Multiline);Console.WriteLine("r16matchcount:"+r16.Matches(i).Count);//1//对于一个多行字符串，在设置了Multiline选项之后，^和$将出现多次匹配。stringi="Livefornothing,dieforsomething";stringm="Livefornothing,dieforsomething";Regexr1=newRegex(@"\bthing\b");Console.WriteLine("r1matchcount:"+r1.Matches(i).Count);//0Regexr2=newRegex(@"thing\b");Console.WriteLine("r2matchcount:"+r2.Matches(i).Count);//2Regexr3=newRegex(@"\bthing\b");Console.WriteLine("r3matchcount:"+r3.Matches(m).Count);//1Regexr4=newRegex(@"\bforsomething\b");Console.WriteLine("r4matchcount:"+r4.Matches(i).Count);//1//\b通常用于约束一个完整的单词
（4）重复描述字符
“重复描述字符”是体现C#正则表达式“很好很强大”的地方之一：
{n} 匹配前面的字符n次
{n,} 匹配前面的字符n次或多于n次
{n,m} 匹配前面的字符n到m次
? 匹配前面的字符0或1次
+ 匹配前面的字符1次或多于1次
* 匹配前面的字符0次或式于0次
以下提供一些简单的示例：
stringx="1024";stringy="+1024";stringz="1,024";stringa="1";stringb="-1024";stringc="10000";Regexr=newRegex(@"^\+?[1-9],?\d{3}$");Console.WriteLine("xmatchcount:"+r.Matches(x).Count);//1Console.WriteLine("ymatchcount:"+r.Matches(y).Count);//1Console.WriteLine("zmatchcount:"+r.Matches(z).Count);//1Console.WriteLine("amatchcount:"+r.Matches(a).Count);//0Console.WriteLine("bmatchcount:"+r.Matches(b).Count);//0Console.WriteLine("cmatchcount:"+r.Matches(c).Count);//0//匹配1000到9999的整数。
（5）择一匹配
C#正则表达式中的 (|) 符号似乎没有一个专门的称谓，姑且称之为“择一匹配”吧。事实上，像[a-z]也是一种择一匹配，只不过它只能匹配单个字符，而(|)则提供了更大的范围，(ab|xy)表示匹配ab或匹配xy。注意“|”与“()”在此是一个整体。下面提供一些简单的示例：
stringx="0";stringy="0.23";stringz="100";stringa="100.01";stringb="9.9";stringc="99.9";stringd="99.";stringe="00.1";Regexr=newRegex(@"^\+?((100(.0+)*)|([1-9]?[0-9])(\.\d+)*)$");Console.WriteLine("xmatchcount:"+r.Matches(x).Count);//1Console.WriteLine("ymatchcount:"+r.Matches(y).Count);//1Console.WriteLine("zmatchcount:"+r.Matches(z).Count);//1Console.WriteLine("amatchcount:"+r.Matches(a).Count);//0Console.WriteLine("bmatchcount:"+r.Matches(b).Count);//1Console.WriteLine("cmatchcount:"+r.Matches(c).Count);//1Console.WriteLine("dmatchcount:"+r.Matches(d).Count);//0Console.WriteLine("ematchcount:"+r.Matches(e).Count);//0//匹配0到100的数。最外层的括号内包含两部分“(100(.0+)*)”，“([1-9]?[0-9])(\.\d+)*”，这两部分是“OR”的关系，即正则表达式引擎会先尝试匹配100，如果失败，则尝试匹配后一个表达式（表示[0,100)范围中的数字）。
（6）特殊字符的匹配
下面提供一些简单的示例：
stringx="\\";Regexr1=newRegex("^\\\\$");Console.WriteLine("r1matchcount:"+r1.Matches(x).Count);//1Regexr2=newRegex(@"^\\$");Console.WriteLine("r2matchcount:"+r2.Matches(x).Count);//1Regexr3=newRegex("^\\$");Console.WriteLine("r3matchcount:"+r3.Matches(x).Count);//0//匹配“\”stringx="\"";Regexr1=newRegex("^\"$");Console.WriteLine("r1matchcount:"+r1.Matches(x).Count);//1Regexr2=newRegex(@"^""$");Console.WriteLine("r2matchcount:"+r2.Matches(x).Count);//1//匹配双引号
（7）组与非捕获组
以下提供一些简单的示例：
stringx="Livefornothing,dieforsomething";stringy="Livefornothing,dieforsomebody";Regexr=newRegex(@"^Live([a-z]{3})no([a-z]{5}),die\1some\2$");Console.WriteLine("xmatchcount:"+r.Matches(x).Count);//1Console.WriteLine("ymatchcount:"+r.Matches(y).Count);//0//正则表达式引擎会记忆“()”中匹配到的内容，作为一个“组”，并且可以通过索引的方式进行引用。表达式中的“\1”，用于反向引用表达式中出现的第一个组，即粗体标识的第一个括号内容，“\2”则依此类推。stringx="Livefornothing,dieforsomething";Regexr=newRegex(@"^Liveforno([a-z]{5}),dieforsome\1$");if(r.IsMatch(x)){
Console.WriteLine("group1value:"+r.Match(x).Groups[1].Value);//输出：thing
}//获取组中的内容。注意，此处是Groups[1]，因为Groups[0]是整个匹配的字符串，即整个变量x的内容。stringx="Livefornothing,dieforsomething";Regexr=newRegex(@"^Liveforno(?<g1>[a-z]{5}),dieforsome\1$");if(r.IsMatch(x)){Console.WriteLine("group1value:"+r.Match(x).Groups["g1"].Value);//输出：thing}//可根据组名进行索引。使用以下格式为标识一个组的名称(?<groupname>…)。stringx="Livefornothingnothing";Regexr=newRegex(@"([a-z]+)\1");if(r.IsMatch(x)){x=r.Replace(x,"$1");Console.WriteLine("varx:"+x);//输出：Livefornothing}//删除原字符串中重复出现的“nothing”。在表达式之外，使用“$1”来引用第一个组，下面则是通过组名来引用：stringx="Livefornothingnothing";Regexr=newRegex(@"(?<g1>[a-z]+)\1");if(r.IsMatch(x)){x=r.Replace(x,"${g1}");Console.WriteLine("varx:"+x);//输出：Livefornothing}stringx="Livefornothing";Regexr=newRegex(@"^Liveforno(?:[a-z]{5})$");if(r.IsMatch(x)){Console.WriteLine("group1value:"+r.Match(x).Groups[1].Value);//输出：(空)}//在组前加上“?:”表示这是个“非捕获组”，即引擎将不保存该组的内容。
（8）贪婪与非贪婪
正则表达式的引擎是贪婪，只要模式允许，它将匹配尽可能多的字符。通过在“重复描述字符”（*,+）后面添加“?”，可以将匹配模式改成非贪婪。请看以下示例：
stringx="Livefornothing,dieforsomething";Regexr1=newRegex(@".*thing");if(r1.IsMatch(x)){Console.WriteLine("match:"+r1.Match(x).Value);//输出：Livefornothing,dieforsomething}Regexr2=newRegex(@".*?thing");if(r2.IsMatch(x)){Console.WriteLine("match:"+r2.Match(x).Value);//输出：Livefornothing}
（9）回溯与非回溯
使用“(?>…)”方式进行非回溯声明。由于正则表达式引擎的贪婪特性，导致它在某些情况下，将进行回溯以获得匹配，请看下面的示例：
stringx="Livefornothing,dieforsomething";Regexr1=newRegex(@".*thing,");if(r1.IsMatch(x)){Console.WriteLine("match:"+r1.Match(x).Value);//输出：Livefornothing,}Regexr2=newRegex(@"(?>.*)thing,");if(r2.IsMatch(x))//不匹配{Console.WriteLine("match:"+r2.Match(x).Value);}//在r1中，“.*”由于其贪婪特性，将一直匹配到字符串的最后，随后匹配“thing”，但在匹配“,”时失败，此时引擎将回溯，并在“thing,”处匹配成功。在r2中，由于强制非回溯，所以整个表达式匹配失败。
（10）正向预搜索、反向预搜索
正向预搜索声明格式：正声明 “(?=…)”，负声明 “(?!...)” ，声明本身不作为最终匹配结果的一部分，请看下面的示例：
stringx="1024used2048free";Regexr1=newRegex(@"\d{4}(?=used)");if(r1.Matches(x).Count==1){Console.WriteLine("r1match:"+r1.Match(x).Value);//输出：1024}Regexr2=newRegex(@"\d{4}(?!used)");if(r2.Matches(x).Count==1){Console.WriteLine("r2match:"+r2.Match(x).Value);//输出：2048}//r1中的正声明表示必须保证在四位数字的后面必须紧跟着“used”，r2中的负声明表示四位数字之后不能跟有“used”。
反向预搜索声明格式：正声明“(?<=)”，负声明“(?<!)”，声明本身不作为最终匹配结果的一部分，请看下面的示例：
stringx="used:1024free:2048";Regexr1=newRegex(@"(?<=used:)\d{4}");if(r1.Matches(x).Count==1){Console.WriteLine("r1match:"+r1.Match(x).Value);//输出：1024}Regexr2=newRegex(@"(?<!used:)\d{4}");if(r2.Matches(x).Count==1){Console.WriteLine("r2match:"+r2.Match(x).Value);//输出：2048}//r1中的反向正声明表示在4位数字之前必须紧跟着“used:”，r2中的反向负声明表示在4位数字之前必须紧跟着除“used:”之外的字符串。
（11）十六进制字符范围
正则表达式中，可以使用 "\xXX" 和 "\uXXXX" 表示一个字符（"X" 表示一个十六进制数）形式字符范围：
\xXX 编号在 0到255 范围的字符，比如：空格可以使用 "\x20" 表示。
\uXXXX 任何字符可以使用 "\u" 再加上其编号的4位十六进制数表示，比如：汉字可以使用“[\u4e00-\u9fa5]”表示。
（12）对[0,100]的比较完备的匹配
下面是一个比较综合的示例，对于匹配[0,100]，需要特殊考虑的地方包括
*00合法，00.合法，00.00合法，001.100合法
*空字符串不合法，仅小数点不合法，大于100不合法
*数值是可带后缀的，如“1.07f”表示该值为一个float类型（未考虑）
Regexr=newRegex(@"^\+?0*(?:100(\.0*)?|(\d{0,2}(?=\.\d)|\d{1,2}(?=($|\.$)))(\.\d*)?)$");stringx="";while(true){x=Console.ReadLine();if(x!="exit")
{if(r.IsMatch(x)){Console.WriteLine(x+"succeed!");
}else{Console.WriteLine(x+"failed!");}}else{break;}}
（13）精确匹配有时候是困难的
有些需求要做到精确匹配比较困难，例如：日期、Url、Email地址等，其中一些你甚至需要研究一些专门的文档写出精确完备的表达式，对于这种情况，只能退而求其次，保证比较精确的匹配。例如对于日期，可以基于应用系统的实际情况考虑一段较短的时间，或者对于像Email的匹配，可以只考虑最常见的形式。
扫一扫
326
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
