.NET正则类及其方法应用

1 概述

10年积累的网站设计制作、成都网站建设经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先网站策划后付款的网站建设流程，更有金州免费网站建设让你可以放心的选择与我们合作。

初学正则时，对于Regex类不熟悉，遇到问题不知道该用哪种方法解决，本文结合一些正则应用的典型应用场景，介绍一下Regex类的基本应用。这里重点进行.NET类的介绍，对于正则的运用，不做深入探讨。

正则的应用最终都是进行模式的匹配，而根据目的的不同，基本上可以分为以下几种应用：验证、提取、替换、分割。结合.NET提供的控件、类以及类的方法，可以很方便的实现这些应用。

以下将结合一些典型的应用场景，对.NET中常见的类、方法及属性进行介绍。本文旨在.NET类基础用法的引导，对于其中涉及到的正则表达式不做深入探讨。本文适合于在.NET平台下使用正则的初学者。

2 基础应用

2.1     验证

验证的目的是为了判断输入的源字符串是否符合某一规律或规则，根据需求的不同，可能是校验整个源字符串，也可能只是校验其中一个子串。

验证在.NET中一般有两种应用，一种是在验证控件RegularExpressionValidator中，另一种是在程序中。

2.1.1  验证控件RegularExpressionValidator
RegularExpressionValidator是.NET自带的一种客户端验证控件，通过简单的设置，即可完成对某控件输入值的校验。

基本应用语法如下：

 
 
 
    
  
  
  
  1. 
  
  
  
  2.       ID="RegularExpressionValidator1" 
    3. 
  
  
  
  3.       runat="server" 
    4. 
  
  
  
  4.       ControlToValidate="TextBox1" 
    5. 
  
  
  
  5.       ErrorMessage="RegularExpressionValidator" 
    6. 
  
  
  
  6.  ValidationExpression="^([1-9][0-9]*|0)(\.[0-9][2])?$"> 
    7. 
  
  
  
  7.    
    8.

对于RegularExpressionValidator控件不做过多介绍，只是说明一下使用时需要注意的几点：

1、  RegularExpressionValidator进行的是客户端验证；

2、  RegularExpressionValidator中正则使用的是JavaScript语法规则；

3、  RegularExpressionValidator控件不能验证输入是否为空。

由于RegularExpressionValidator做的是客户端验证，很容易被跳过，所以在使用RegularExpressionValidator验证的同时，还要做服务器端验证。

RegularExpressionValidator最终是要生成客户端的JavaScript代码进行验证的，所以RegularExpressionValidator使用的正则要求符合JavaScript语法规则，与.NET的几点区别：

1、  不支持逆序环视，也就是(?<=Expression)和(?

2、  元字符仅支持ASCII码，即\w等价于[a-zA-Z0-9_]，\d等价于[0-9]

RegularExpressionValidator控件一般是用来验证某一控件输入的字符串整体是否符合某一规则的，所以通常情况下“^”和“$”是必不可少的；在使用“|”表示“或”的关系时，一定要用“()”来限定“|”作用范围，比如0-100可以写作“^([1-9]?[0-9]|100)$”。

RegularExpressionValidator是不能验证输入是否为空的，验证是否为空要用RequiredFieldValidator控件。

RegularExpressionValidator验证控件是.NET为方便客户端验证封装的一组验证控件之一，但由于RegularExpressionValidator受限于支持的正则语法规则，只能做有限的格式校验，一些复杂的校验可以通过自己写JavaScript代码来实现，也是很简单的。

2.1.2  程序验证——IsMatch()
程序中的校验基本上就是使用IsMatch方法，验证的对象可能是源字符串的整体，也可能只是其中一个子串。

验证源字符串的整体是否符合某一规则，与使用RegularExpressionValidator时的需求基本上一致，不过由于是在.NET程序中，所以使用的是.NET的语法，比JavaScript中要强大得多。比如验证一个文本框输入的字符串是否符合某一规则，就是一个典型的验证整体的需求。

举例1：验证textBox1输入内容，要求整数部分为0或正整数，小数可有可无，有小数时必须为2位。

 
 
 
    
  
  
  
  1. Regex reg = new Regex(@"^(?:[1-9][0-9]*|0)(?:\.[0-9]{2})?$");  
    2. 
  
  
  
  2. if (reg.IsMatch(textBox1.Text))  
    3. 
  
  
  
  3. {  
    4. 
  
  
  
  4.     richTextBox2.Text = "输入格式正确！";  
    5. 
  
  
  
  5. }  
    6. 
  
  
  
  6. else 
    7. 
  
  
  
  7. {  
    8. 
  
  
  
  8.     richTextBox2.Text = "输入格式错误！";  
    9. 
  
  
  
  9. } 
    10.

由于是对源字符串的整体进行验证，所以“^”和“$”是必不可少的。否则验证的结果可能是错误的，比如正则表达式“(?:[1-9][0-9]*|0)(?:\.[0-9]{2})?”，在输入“0.123”时是可以匹配成功的，匹配结果为“0.12”，此时正则只起到了匹配的作用，没有起到验证的作用。

验证源字符串的局部是否符合某一规则，就是对于源字符串中子串的校验，通常是用来判断源字符串中是否包含，或是不包含符合某一规律的子串，作用类似于string类中的IndexOf。

举例2（参考问两个正则表达式）：

数据:

1985aaa1985bb

bcae1958fiefadf1955fef

atijc1944cvkd

df2564isdjfef2564d

abc1234def5678ghi5678jkl

需求1：验证字符串中任意位置出现的连续四个数字在整个字符串中是否有重复，有重复为True，无重复为False。

以上数据需求1的验证结果为True的应为：

1985aaa1985bb

df2564isdjfef2564d

abc1234def5678ghi5678jkl

因为需求中指明是任意位置的连续4个数字是否有重复，所以在找到重复前，要遍历源字符串中每一个位置时行验证，这样就不能限定开始标识符“^”；而在匹配过程中，除非一直到结尾仍找不到重复，否则只要匹配到有重复的位置就可以了，这样也不需要结束标识符“$”，所以这是典型的对字符串的子串行验证的需求。

代码实现：

 
 
 
    
  
  
  
  1. string[] test = new string[] { "1985aaa1985bb", "bcae1958fiefadf1955fef", 
    2. 
  
  
  
  2. "atijc1944cvkd", "df2564isdjfef2564d", "abc1234def5678ghi5678jkl" };  
    3. 
  
  
  
  3. Regex reg = new Regex(@"(\d{4})(?:(?!\1).)*\1");  
    4. 
  
  
  
  4. foreach (string s in test)  
    5. 
  
  
  
  5. {  
    6. 
  
  
  
  6. richTextBox2.Text += "源字符串：  " + s.PadRight(25, ' ') + "验证结果：  " + reg.IsMatch(s) + "\n";  
    7. 
  
  
  
  7. }  
    8. 
  
  
  
  8. /*--------输出-------- 
    9. 
  
  
  
  9. 源字符串：  1985aaa1985bb           验证结果：  True
    10. 
  
  
  
  10. 源字符串：  bcae1958fiefadf1955fef  验证结果：  False
    11. 
  
  
  
  11. 源字符串：  atijc1944cvkd            验证结果：  False
    12. 
  
  
  
  12. 源字符串：  df2564isdjfef2564d      验证结果：  True
    13. 
  
  
  
  13. 源字符串：  abc1234def5678ghi5678jkl 验证结果：  True*/
    14.

由于涉及到了重复问题，所以这里用到了反向引用，对于反向引用的细节，可以参考正则基础之——反向引用。

需求2：验证字符串中第一个出现的连续4个数字是否有重复，有重复为True，无重复为False。

以上数据需求2的验证结果为True的应为：

1985aaa1985bb

df2564isdjfef2564d

因为需求中指明是第一个是否有重复，所以需要有开始标识符“^”，来保证是第一个出现的连续4个数字；而在匹配过程中，除非一直到结尾仍找不到重复，否则只要匹配到有重复的位置就可以了，这样也不需要结束标识符“$”，所以这仍是对字符串的子串行验证的需求，只不过相对于需求1来说，加了一个限定条件。

代码实现：

 
 
 
    
  
  
  
  1. string[] test = new string[] { "1985aaa1985bb", "bcae1958fiefadf1955fef",
    2. 
  
  
  
  2.  "atijc1944cvkd", "df2564isdjfef2564d", "abc1234def5678ghi5678jkl" };  
    3. 
  
  
  
  3. Regex reg = new Regex(@"^(?:(?!\d{4}).)*(\d{4})(?:(?!\1).)*\1");  
    4. 
  
  
  
  4. foreach (string s in test)  
    5. 
  
  
  
  5. {  
    6. 
  
  
  
  6.      richTextBox2.Text += "源字符串：  " + s.PadRight(25, ' ') + "验证结果：  " + reg.IsMatch(s) + "\n";  
    7. 
  
  
  
  7. }  
    8. 
  
  
  
  8. /*--------输出--------  
    9. 
  
  
  
  9. 源字符串：  1985aaa1985bb            验证结果：  True  
    10. 
  
  
  
  10. 源字符串：  bcae1958fiefadf1955fef   验证结果：  False  
    11. 
  
  
  
  11. 源字符串：  atijc1944cvkd            验证结果：  False  
    12. 
  
  
  
  12. 源字符串：  df2564isdjfef2564d       验证结果：  True  
    13. 
  
  
  
  13. 源字符串：  abc1234def5678ghi5678jkl 验证结果：  False  
    14. 
  
  
  
  14. */ 
    15.

2.2     提取——Match()、Matches()

提取主要是从源字符串中，取得一个或多个符合某一规律或规则的子串。一般来说，在字符串处理中，提取应用比较广泛。提取时用得比较多的是Match()和Matches()方法，以及结果处理时Match类和MatchCollection类的一些方法，有时也会用到Capture类的一些方法。

2.2.1  提取单次匹配内容——Match()

当需要提取的内容只有一个，或是只需要获取第一次成功匹配的内容时，可以使用Match()方法。当使用Match()方法时，只要在某一位置匹配成功，就不再继续尝试匹配，并返回一个Match类型的对象。

举例：提取姓名

源字符串：姓名：张三，性别：男，年龄：25

代码实现：

 
 
 
    
  
  
  
  1. string test = "姓名：张三，性别：男，年龄：25";  
    2. 
  
  
  
  2. Regex reg = new Regex(@"(?<=姓名：)[^，]+");  
    3. 
  
  
  
  3. Match m = reg.Match(test);  
    4. 
  
  
  
  4. if (m.Success)    //验证是否匹配成功  
    5. 
  
  
  
  5. {  
    6. 
  
  
  
  6.       richTextBox2.Text = m.Value;  
    7. 
  
  
  
  7. }  
    8. 
  
  
  
  8. /*--------输出--------  
    9. 
  
  
  
  9. 张三  
    10. 
  
  
  
  10. */ 
    11.

虽然Match()只是取一次匹配，但是可以通过捕获组来获取多个指定子串，比如获取第一个标签的链接和文本。

 
 
 
    
  
  
  
  1. string test = "abc测试一def测试二ghi";  
    2. 
  
  
  
  2. Regex reg = new Regex(@"(?is)[^""\s>]*)\1[^>]*>(?(?:(?!");  
    3. 
  
  
  
  3. Match m = reg.Match(test);  
    4. 
  
  
  
  4. if(m.Success)  
    5. 
  
  
  
  5. {  
    6. 
  
  
  
  6.      richTextBox2.Text += m.Groups["url"].Value + "\n";      //链接  
    7. 
  
  
  
  7.      richTextBox2.Text += m.Groups["text"].Value + "\n";     //文本  
    8. 
  
  
  
  8. }  
    9. 
  
  
  
  9. /*--------输出--------  
    10. 
  
  
  
  10. www.test1.com  
    11. 
  
  
  
  11. 测试一  
    12. 
  
  
  
  12. */ 
    13.

对于捕获组捕获结果的引用，还有一种方式

 
 
 
    
  
  
  
  1. string test = "abc测试一def测试二ghi";  
    2. 
  
  
  
  2. Regex reg = new Regex(@"(?is)[^""\s>]*)\1[^>]*>(?(?:(?!"); Match m = reg.Match(test);  
    3. 
  
  
  
  3. if(m.Success)  
    4. 
  
  
  
  4. {  
    5. 
  
  
  
  5.      richTextBox2.Text += m.Result("${url}") + "\n";      //链接  
    6. 
  
  
  
  6.      richTextBox2.Text += m.Result("${text}") + "\n";     //文本  
    7. 
  
  
  
  7. }  
    8. 
  
  
  
  8. /*--------输出--------  
    9. 
  
  
  
  9. www.test1.com  
    10. 
  
  
  
  10. 测试一  
    11. 
  
  
  
  11. */ 
    12.

这两种方法获取的结果都是一样的，使用哪一种，通常根据个人习惯而定。

2.2.2  提取多次匹配内容——Matches()
当需要提取的内容有多个，并且需要提取所有符合规律的子串时，可以使用Matches()方法。当使用Matches()方法时，需要遍历源字符串的每一个位置进行尝试匹配，匹配结束返回一个MatchCollection类型的对象。

对于1.2.1节提到的提取链接和文本的例子，如果提取的是全部链接和文本，而不仅仅是第一个时，可以使用Matches()方法。

 
 
 
    
  
  
  
  1. string test = "abc测试一def测试二ghi";  
    2. 
  
  
  
  2.  
    3. 
  
  
  
  3. Regex reg = new Regex(@"(?is)[^""\s>]*)\1[^>]*>(?(?:(?!");  
    4. 
  
  
  
  4. MatchCollection mc = reg.Matches(test);  
    5. 
  
  
  
  5. foreach(Match m in mc)  
    6. 
  
  
  
  6. {  
    7. 
  
  
  
  7.      richTextBox2.Text += m.Groups["url"].Value + "\n";      //链接  
    8. 
  
  
  
  8.      richTextBox2.Text += m.Groups["text"].Value + "\n";     //文本  
    9. 
  
  
  
  9. }  
    10. 
  
  
  
  10. /*--------输出--------  
    11. 
  
  
  
  11. www.test1.com  
    12. 
  
  
  
  12. 测试一  
    13. 
  
  
  
  13. www.test2.com  
    14. 
  
  
  
  14. 测试二  
    15. 
  
  
  
  15. */ 
    16.

对于Matches()，某些场景下，也可以通过Count属性，用做统计符合某一规律的子串出现的次数，例如统计字符串中独立的“3”出现的次数。

 
 
 
    
  
  
  
  1. string test = "137,1,33,4,3,6,21,3,35,93,2,98";  
    2. 
  
  
  
  2. Regex reg = new Regex(@"\b3\b");  
    3. 
  
  
  
  3. int count = reg.Matches(test).Count;    //2 
    4.

这时候关心的只是匹配成功的次数，对于匹配的内容是不关心的，所以实现这种需求时，正则应尽量简洁，能达到目的即可，这样可以加快匹配效率，减少资源占用。比如上面的提取链接的源字符串中，统计标签出现的次数，一般来说，如下代码即可达到目的了。

 
 
 
    
  
  
  
  1. string test = "abc
    2. 
  
  
  
  2. 测试一def测试二ghi";  
    3. 
  
  
  
  3. Regex reg = new Regex(@"(?i)
  
  
  
  4. int count = reg.Matches(test).Count;    //2 
    5.

2.2.3  捕获组匹配过程集合——Capture
在某些情况下，一个正则表达式整体匹配一次时，其中的捕获组可能会匹配多次。

举例：

源字符串：abcsadf jfdsajf  abcsadf

需求：提取出每个region的属性和属性值，按region分组。

对于这个需求，可以先提取出所有region，再对每个region标签提取它的属性和属性值，但这样做比较麻烦，可以考虑在一个正则表达式中提取。由于属性的个数是不固定的，所以不能用固定个数的量词来匹配属性对，正则可以写为

 
 
 
    
  
  
  
  1. (?is)[^\s=]+)=(?[^\s>]+)\s*)+> 
    2.

此时如果还用Groups来取匹配结果时，由于Groups只保留最后一次匹配结果，所以只能取到最后一次匹配成功的子串。这时就要用到Captures属性。

 
 
 
    
  
  
  
  1. string test = "abcsadf
    2. 
  
  
  
  2.   jfdsajf  
    3. 
  
  
  
  3. abcsadf
    4. 
  
  
  
  4.  ";  
    5. 
  
  
  
  5. MatchCollection mc = Regex.Matches(test, @"(?is)
    6. 
  
  
  
  6. [^\s=]+)=(?[^\s>]+)\s*)+>");  
    7. 
  
  
  
  7. for (int i = 0; i < mc.Count; i++)  
    8. 
  
  
  
  8. {  
    9. 
  
  
  
  9.     richTextBox2.Text += "第" + (i + 1) + "个region的属性：\n";  
    10. 
  
  
  
  10.     for (int j = 0; j < mc[i].Groups["key"].Captures.Count; j++)  
    11. 
  
  
  
  11.     {  
    12. 
  
  
  
  12. richTextBox2.Text += "属性： " + mc[i].Groups["key"].Captures[j].Value.PadRight(10, ' ')
    13. 
  
  
  
  13.  + "  值： " + mc[i].Groups["value"].Captures[j].Value + "\n";  
    14. 
  
  
  
  14.  
    15. 
  
  
  
  15.     }  
    16. 
  
  
  
  16.     richTextBox2.Text += "\n";  
    17. 
  
  
  
  17. }  
    18. 
  
  
  
  18. /*--------输出-------- 
    19. 
  
  
  
  19. 第1个region的属性：
    属性： name        值： oldslist
    属性： col         值： 1
    属性： row         值： 2
    属性： order       值： asc
    第2个region的属性：
    属性： name        值： newslist
    属性： class       值： list
    属性： col         值： 4
    属性： row         值： 10
    属性： order       值： desc
    */
    20.

Group实际上是Capture的一个集合，在捕获组只匹配一个子串时，这个集合只有一个元素，而在捕获组先后匹配多个子串时，Groups[i].Value只保留最后一个匹配结果，而Capture集合却可以记录匹配过程中匹配到的所有子串。

Capture的应用场景并不多，对于上面的例子，如果不使用 Capture，可以通过分次匹配的方式实现，但是在一些复杂的表达式中，很难进行分次匹配，这时Capture就比较有用了。

2.3      替换

替换主要是从源字符串中，将符合某一规律或规则的子串替换为其它内容。一般来说，在字符串处理中，替换应用也比较广泛。替换主要是用Replace()方法，在一些替换规则复杂的应用场景中，也可能会用到委托方法。

2.3.1  一般替换

替换的目的很明确，只要找出待替换子串的规律，替换为目标子串就可以了。

举例1：

源字符串： abc

需求：将相对地址替换为绝对地址，已经是绝对地址的不替换。

 
 
 
    
  
  
  
  1. string test = " abc ";  
    2. 
  
  
  
  2. Regex reg = new Regex(@"(?i)(?<=src=(['""]?))(?!http://)(?=[^'""\s>]+\1)");  
    3. 
  
  
  
  3. string result = reg.Replace(test, "http://www.test.com");  
    4. 
  
  
  
  4. /*--------输出--------  
    5. 
  
  
  
  5.  abc   
    6. 
  
  
  
  6. */ 
    7.

这里需要说明的是，在.NET中只提供了一个Replace()方法，没有提供类似于Java中的replaceAll()和replaceFirst()两种方法，所以如果在.NET中只替换第一次出现的符合规律的子串时，需要在正则表达式中处理。

举例2：

源字符串：abc123def123ghi

需求：将第一次出现的“123”替换为空，其余位置不替换。

 
 
 
    
  
  
  
  1. string test = "abc123def123ghi";  
    2. 
  
  
  
  2. Regex reg = new Regex(@"(?s)^((?:(?!123).)*)123");  
    3. 
  
  
  
  3. string result = reg.Replace(test, "$1");  
    4. 
  
  
  
  4. /*--------输出--------  
    5. 
  
  
  
  5. abcdef123ghi  
    6. 
  
  
  
  6. */ 
    7.

这时用“^”限定只替换第一次出现的子串，由于绝大多数正则引擎都对“^”进行了优化，所以正则表达式在位置0处匹配成功或失败后，将不再对其它位置进行尝试匹配。

2.3.2  替换中的委托方法应用

对于一些比较复杂的替换规则，可能会用到委托方法，由于这种应用属于比较典型的一种应用，所以将在后面的文章中单独进行介绍

2.4     分割

分割就是用符合某一规律的子串，将源字符串分割成一个数组，主要用到的是Split()方法。由于Regex的Split()方法中，并没有提供类似于string的Split()方法的StringSplitOptions.RemoveEmptyEntries参数，而如果符合规律的子串出现在开头或结尾时，会出现不需要的空串，这时需要在正则表达式中进行一下处理。

举例1：

源字符串：汉字123文字english

需求：按英文单词和非英文单词进行分割（英文单词包括由a-z,A-Z,0-9,_组成的子串）。

 
 
 
    
  
  
  
  1. string str = "汉字123文字english";  
    2. 
  
  
  
  2. string[] result = Regex.Split(str, @"(?
  
  
  
  3. foreach (string s in result)  
    4. 
  
  
  
  4. {  
    5. 
  
  
  
  5.      richTextBox2.Text += s + "\n";  
    6. 
  
  
  
  6. }  
    7. 
  
  
  
  7. /*--------输出--------  
    8. 
  
  
  
  8. 汉字  
    9. 
  
  
  
  9. 123  
    10. 
  
  
  
  10. 文字  
    11. 
  
  
  
  11. English  
    12. 
  
  
  
  12. */ 
    13.

这里分别用“(?

还有一些应用，其实可以算作是正则就用技巧范畴的了。

举例2：

源字符串：Left(姓名,1),Left(姓名,1) ,  Left    (姓名,1)

需求：以不在“()”内的“,”进行分割。

 
 
 
    
  
  
  
  1. string test = "Left(姓名,1),Left(姓名,1) ,  Left    (姓名,1)";  
    2. 
  
  
  
  2. Regex reg = new Regex(@"(?
  
  
  
  3. string[] sArray = reg.Split(test);  
    4. 
  
  
  
  4. foreach (string s in sArray)  
    5. 
  
  
  
  5. {  
    6. 
  
  
  
  6.      richTextBox2.Text += s + "\n";  
    7. 
  
  
  
  7. }  
    8. 
  
  
  
  8. /*--------输出--------  
    9. 
  
  
  
  9. Left(姓名,1)  
    10. 
  
  
  
  10. Left(姓名,1)  
    11. 
  
  
  
  11.   Left    (姓名,1)  
    12. 
  
  
  
  12. */ 
    13.

使用正则的Split()方法时，有一点需求注意，那就是如果正则中出现了捕获组，那么捕获组匹配到的内容也会保存到分割结果中。

以下举例不做详细说明，看下结果基本上就明白了。

 
 
 
    
  
  
  
  1. string test = "aa11cc22ee";  
    2. 
  
  
  
  2. string[] temp = Regex.Split(test, @"[0-9]+(<[^>]*>)");  
    3. 
  
  
  
  3. foreach (string s in temp)  
    4. 
  
  
  
  4. {  
    5. 
  
  
  
  5.      richTextBox2.Text += s + "\n";  
    6. 
  
  
  
  6. }  
    7. 
  
  
  
  7. /*--------输出--------  
    8. 
  
  
  
  8. aa  
    9. 
  
  
  
  9.   
    10. 
  
  
  
  10. cc  
    11. 
  
  
  
  11.   
    12. 
  
  
  
  12. ee  
    13. 
  
  
  
  13. */ 
    14.

 如果不想把捕获组匹配到的内容也存入结果，可以使用非捕获组。 

 
 
 
    
  
  
  
  1. string test = "aa11cc22ee";  
    2. 
  
  
  
  2. string[] temp = Regex.Split(test, @"[0-9]+(?:<[^>]*>)");  
    3. 
  
  
  
  3. foreach (string s in temp)  
    4. 
  
  
  
  4. {  
    5. 
  
  
  
  5.      richTextBox2.Text += s + "\n";  
    6. 
  
  
  
  6. }  
    7. 
  
  
  
  7. /*--------输出--------  
    8. 
  
  
  
  8. aa  
    9. 
  
  
  
  9. cc  
    10. 
  
  
  
  10. ee  
    11. 
  
  
  
  11. */ 
    12.

3       扩展应用

这里介绍一些可能涉及到的一些.NET中的正则扩展应用。

3.1     动态生成正则时的转义——Escape()

有时需要根据一些变量动态生成正则表达式，这时如果变量中含有正则中的元字符，会被解析成元字符，就可能会导致正则编译不通过，从而导致程序异常，需要对变量进行转义处理。Regex. Escape()方法通过替换为转义码来转义最小的字符集（\、*、+、?、|、{、[、(、)、^、$、.、# 和空白）。

比如根据用户输入的id取相应的div标签，id中没有元字符时，可以取得正确结果。

 
 
 
    
  
  
  
  1. string test = "abc
def
";             
  • string[] ids = new string[] { "test1", "test2" };  
  • foreach (string id in ids)  
  • {  
  • Regex reg = new Regex(@"(?is)]*>(?:(?!");  
  •      MatchCollection mc = reg.Matches(test);  
  •      foreach (Match m in mc)  
  •      {  
  •           richTextBox2.Text += m.Value + "\n";  
  •      }  
  • }  
  • /*--------输出--------  
  • abc
    •  
  • def  
  • */ 

    • 但是如果输入的id中一旦出现未经转义的元字符，如“abc(”，就会抛类似于下面的异常。

    正在分析“(?is)]*>(?:(?!”－ ) 不足。

    此时可以用Escape()方法对输入的变量进行转义处理。

     
 
 
      
  
  
  
    1. string test = "abcdef";             
      2. 
  
  
  
    2. string[] ids = new string[] { "test1", "test2", "abc(" };  
      3. 
  
  
  
    3. foreach (string id in ids)  
      4. 
  
  
  
    4. {  
      5. 
  
  
  
    5.      Regex reg = new Regex(@"(?is)]*>(?:(?!");  
      6. 
  
  
  
    6.      MatchCollection mc = reg.Matches(test);  
      7. 
  
  
  
    7.      foreach (Match m in mc)  
      8. 
  
  
  
    8.      {  
      9. 
  
  
  
    9.           richTextBox2.Text += m.Value + "\n";  
      10. 
  
  
  
    10.      }  
      11. 
  
  
  
    11. }  
      12. 
  
  
  
    12. /*--------输出--------  
      13. 
  
  
  
    13. abc  
      14. 
  
  
  
    14. def  
      15. 
  
  
  
    15. */ 
      16.

    使用Escape()方法转义后，就可以得到正确的结果，而不会抛异常了。

    3.2     静态方法

    .NET中一些Regex类的常见方法都提供了相应的静态方法，可以不显式的声明Regex对象，而直接调用相应的方法，书写起来更方便，代码更简洁、易读。

    比如替换IP地址最后一节为“*”，只需一行代码。

    string result = Regex.Replace("10.27.123.12", @"\d+$", "*");   //10.27.123.*

    静态方法每次调用都会创建一个临时的Regex对象，使用之后释放，所以每次调用静态方法时，都会重新编译，而这将会降低执行效率。因此在循环或是频繁调用的方法中，不适合使用静态方法，而需要进行显式声明Regex对象。

    但是对于一些只调用一次，或是对执行效率没有要求的场景下，静态方法则是很不错的选择。

    本文来自CSDN博客：http://blog.csdn.net/lxcnn/archive/2009/10/12/4656599.aspx

    【编辑推荐】

    1. 什么是正则表达式：其历史与.NET框架的关系
    2. 详解C#正则表达式
    3. 利用正则表达式使C#判断输入日期格式是否正确
    4. .NET下正则表达式应用四例
    5. JAVA正则表达式4种常用的功能

    本文标题：.NET正则类及其方法应用
    新闻来源：http://www.shufengxianlan.com/qtweb/news3/21453.html

    网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

    广告

    声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

    猜你还喜欢下面的内容

    企业建站知识

    同城分类信息

    响应式网站　　 　小程序开发　　 　成都艺考培训　　 　成都服务器运维　　 　宏昇商务服务　　 　宜宾网站营销推广　　 　南部网站建设　　 　成都网站建设公司　　 　托管服务器　　 　企业官网建设　　 　资阳网站建设　　 　网站快速收录　　 　红锐电子　　 　成都关键词SEO优化　　 　网站营销推广　　 　简阳网站制作　　 　成都响应式网站建设公司　　 　成都400电话　　 　服务器托管　　 　郫县明安消防器材