C# 使用正则表达式

微软技术分享

已于 2023-07-02 16:34:34 修改

阅读量2.3w

点赞数 4

文章标签：正则表达式开发语言 c# VisualC# visualstudio

于 2020-06-18 11:05:00 首次发布

本文链接：https://blog.csdn.net/lyshark_csdn/article/details/124939207

版权

博客园搬家专栏收录该内容

193 篇文章 23 订阅

订阅专栏

正则表达式是一种用于匹配和处理文本的强大工具，常用于字符串的搜索、替换、验证等操作。在C#中，可以使用System.Text.RegularExpressions命名空间提供的类来处理正则表达式。

正则表达式由一系列字符和特殊字符组成，用于定义模式或规则，用于匹配和操作字符串。它具有灵活、强大的模式匹配能力，可以根据特定的模式对文本进行高效的搜索和操作。

以下是正则表达式中常用的一些特殊字符和符号：

.：匹配任意单个字符，除了换行符。
*：匹配前面的元素零次或多次。
+：匹配前面的元素一次或多次。
?：匹配前面的元素零次或一次。
[]：定义字符集，匹配其中的任意一个字符。
()：用于分组，将其中的元素视为一个整体。
|：表示或操作，匹配两个或多个表达式之一。
\d：匹配任意一个数字字符。
\w：匹配任意一个字母、数字或下划线字符。
\s：匹配任意一个空白字符。

在C#中，可以使用Regex类来创建正则表达式对象，并使用其方法进行匹配、搜索、替换等操作。常用的方法包括：

Match：在输入字符串中查找第一个匹配项。
Matches：在输入字符串中查找所有匹配项。
Replace：替换匹配项。
Split：根据匹配项将输入字符串拆分为多个子字符串。

以下是一个简单的示例代码，展示了如何使用正则表达式进行匹配和替换：

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main(string[] args)
    {
        string input = "Hello, lyshark!";
        string pattern = @"\b\w+";

        MatchCollection matches = Regex.Matches(input, pattern);

        foreach (Match match in matches)
        {
            Console.WriteLine(match.Value);
        }

        string replaced = Regex.Replace(input, pattern, "example");

        Console.WriteLine(replaced);
    }
}

上述代码使用正则表达式\b\w+对字符串进行匹配，将找到的单词逐个输出，并使用正则表达式将字符串中的单词替换为"example"。运行代码后，输出结果如下：

Hello
lyshark
example, example!

总的来说，正则表达式是一个强大的文本处理工具，在C#中可以通过Regex类进行使用。通过定义模式和使用特殊字符，可以进行字符串的搜索、替换、验证等操作，提供了灵活、高效的文本处理功能。

正则表达式匹配条件

常用的针对数字的匹配符号

Regex(@"^[0-9]*$");                       // 匹配0-9数字
Regex(@"^\d{n}$");                        // 匹配出现过n次的数字
Regex(@"^\d{n,}$");                       // 匹配至少出现过n次的数字
Regex(@"^\d{m,n}$");                      // 匹配最小出现过m次最大n次的数字
Regex(@"^(0|[1-9][0-9]*)$");              // 匹配零和非零开头的数字
Regex(@"^([1-9][0-9]*)+(.[0-9]{1,2})?$"); // 匹配非零开头的最多带两位小数的数字
Regex(@"^(\-)?\d+(\.\d{1,2})?$");         // 匹配带1-2位小数的正数或负数
Regex(@"^(\-|\+)?\d+(\.\d+)?$");          // 匹配正数、负数、和小数
Regex(@"^[0-9]+(.[0-9]{2})?$");           // 匹配有两位小数的正实数
Regex(@"^[0-9]+(.[0-9]{1,3})?$");         // 匹配有1~3位小数的正实数

Regex(@"^[1-9]\d*$");                     // 匹配非零的正整数                 
Regex(@"^([1-9][0-9]*){1,3}$");           // 同上
Regex(@"^\+?[1-9][0-9]*$");               // 同上

Regex(@"^\-[1-9][]0-9"*$);                // 匹配非零负整数
Regex(@"^-[1-9]\d*$");

Regex(@"^\d+$");                          // 匹配非负整数
Regex(@"^[1-9]\d*|0$");
Regex(@"^-[1-9]\d*|0$");                  // 匹配非正整数
Regex(@"^((-\d+)|(0+))$");

Regex(@"^(-?\d+)(\.\d+)?$");              // 匹配浮点数
Regex(@"^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$");

Regex(@"^\d+(\.\d+)?$");                  // 匹配非负浮点数
Regex(@"^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$");

Regex(@"^((-\d+(\.\d+)?)|(0+(\.0+)?))$"); // 匹配非正浮点数
Regex(@"^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$");

Regex(@"^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$")     // 匹配正浮点数
Regex(@"^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$");

Regex(@"^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$"); // 匹配负浮点数
Regex(@"^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$");

校验字符的表达式

Regex(@"^[\u4e00-\u9fa5]{0,}$");          // 匹配汉字
Regex(@"^[A-Za-z0-9]+$");                 // 匹配英文和数字
Regex(@"^[A-Za-z0-9]{4,40}$");            // 匹配应为和数字,最小4位最大40位
Regex(@"^.{3,20}$");                      // 匹配长度为3-20的所有字符

Regex(@"^[A-Za-z]+$");                    // 匹配由26个英文字母组成的字符串
Regex(@"^[A-Z]+$");                       // 匹配由26个大写英文字母组成的字符串
Regex(@"^[a-z]+$");                       // 匹配由26个小写英文字母组成的字符串
Regex(@"^[A-Za-z0-9]+$");                 // 匹配由数字和26个英文字母组成的字符串
Regex(@"^\w+$ 或 ^\w{3,20}$");            // 匹配由数字、26个英文字母或者下划线组成的字符串

Regex(@"^[\u4E00-\u9FA5A-Za-z0-9_]+$");     // 匹配中文、英文、数字包括下划线
Regex(@"^[\u4E00-\u9FA5A-Za-z0-9]+$");      // 匹配中文、英文、数字但不包括下划线等符号
Regex(@"^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$"); // 同上,不过这里可以限制长度

Regex(@"[^%&’,;=?$\x22]+");                 // 可以输入含有^%&’,;=?$\"等字符
Regex(@"[^~\x22]+");                        // 禁止输入含有~的字符

特殊需求表达式

Regex(@"^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$");   // 验证email地址

Regex(@"[a-zA-z]+://[^\s]*");                              // 验证URL网址
Regex(@"^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$");
Regex(@"^([a-zA-Z]+://)?([\w-\.]+)(\.[a-zA-Z0-9]+)(:\d{0,5})?/?([\w-/]*)\.?([a-zA-Z]*)\??(([\w-]*=[\w%]*&?)*)$");

Regex(@"^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$");  // 验证手机号码

Regex(@"^($$\d{3,4}-)|\d{3.4}-)?\d{7,8}$");               // 验证电话号码
Regex(@"\d{3}-\d{8}|\d{4}-\d{7}");                        // 验证国内电话号码

Regex(@"^\d{15}|\d{18}$");                                                 // 身份证号(15位、18位数字)
Regex(@"^([0-9]){7,18}(x|X)?$ 或 ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$");  // 短身份证号码(数字、字母x结尾)

//帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)
Regex(@"^[a-zA-Z][a-zA-Z0-9_]{4,15}$");

//密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)
Regex(@"^[a-zA-Z]\w{5,17}$");

//强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在8-10之间)
Regex(@"^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$");

//日期格式
Regex(@"^\d{4}-\d{1,2}-\d{1,2}");
//一年的12个月(01～09和1～12)
Regex(@"^(0?[1-9]|1[0-2])$");
//一个月的31天(01～09和1～31)
Regex(@"^((0?[1-9])|((1|2)[0-9])|30|31)$");


//钱的输入格式：
//有四种钱的表示形式我们可以接受:”10000.00″ 和 “10,000.00”, 和没有 “分” 的 “10000” 和 “10,000”
Regex(@"^[1-9][0-9]*$");

//这表示任意一个不以0开头的数字，但是，这也意味着一个字符”0″不通过，所以我们采用下面的形式
Regex(@"^(0|[1-9][0-9]*)$");

//一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号
Regex(@"^(0|-?[1-9][0-9]*)$");

//这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉，因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分
Regex(@"^[0-9]+(.[0-9]+)?$");

//必须说明的是，小数点后面至少应该有1位数，所以”10.”是不通过的，但是 “10” 和 “10.2” 是通过的
Regex(@"^[0-9]+(.[0-9]{2})?$");
//这样我们规定小数点后面必须有两位，如果你认为太苛刻了，可以这样
Regex(@"^[0-9]+(.[0-9]{1,2})?$");
//这样就允许用户只写一位小数。下面我们该考虑数字中的逗号了，我们可以这样
Regex(@"^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$");
//1到3个数字，后面跟着任意个 逗号+3个数字，逗号成为可选，而不是必须
Regex(@"^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$");

//xml文件
Regex(@"^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$");
//中文字符的正则表达式
Regex(@"[\u4e00-\u9fa5]");
//双字节字符
Regex(@"[^\x00-\xff] (包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1))");
//空白行的正则表达式，可用来删除空白行
Regex(@"\n\s*\r");
//HTML标记的正则表达式
Regex(@"<(\S*?)[^>]*>.*?</\1>|<.*? />");// (网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力)
//首尾空白字符的正则表达式
Regex(@"^\s*|\s*$或(^\s*)|(\s*$)");// (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式)
//腾讯QQ号
Regex(@"[1-9][0-9]{4,}"); //(腾讯QQ号从10000开始)
//中国邮政编码
Regex(@"[1-9]\d{5}(?!\d)");// (中国邮政编码为6位数字)
//IP地址
Regex(@"\d+\.\d+\.\d+\.\d+");// (提取IP地址时有用)
Regex(@"((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))");

使用正则匹配

C#中字符串常量以@开头,这样优点是转义序列不被处理，按“原样”输出

matches = 在指定的输入字符串中搜索正则表达式的所有匹配项。
match = 在指定的输入字符串中搜索 Regex 构造函数中指定的正则表达式的第一个匹配项。

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // 正则匹配的基本使用1

            string str = "Address=192.168.1.1;Name=lyshark;Host=9999";

            Regex reg = new Regex("Name=(.+);");  // 设置匹配条件
            Match match = reg.Match(str);         // 匹配

            string value = match.Groups[0].Value; // 获取到匹配结果
            Console.WriteLine("匹配到数据: " + value);

            // 正则匹配的基本使用2
            string input = "1986 1997 2005 2009 2019 1951 1999 1950 1905 2003";
            string pattern = @"(?<=19)\d{2}\b";

            foreach(Match each in Regex.Matches(input,pattern))
            {
                Console.WriteLine("匹配到时间: " + each.Value);
            }

            Console.ReadKey();
        }
    }
}

以上代码是一个使用正则表达式进行匹配的示例。

在第一个示例中，定义了一个字符串str，使用正则表达式Name=(.+);进行匹配。Name=表示匹配以Name=开头的字符串，(.+)表示匹配任意字符（至少一个字符），;表示匹配分号。然后使用Regex.Match方法进行匹配，并通过Match.Groups[0].Value获取到匹配结果。最后将结果输出到控制台。

在第二个示例中，定义了一个字符串input，使用正则表达式(?<=19)\d{2}\b匹配以19开头的两位数。(?<=19)使用正则表达式的正向后行断言，表示匹配以19开头的字符串但不包括19本身，\d{2}表示匹配两位数字，\b表示单词边界。然后使用Regex.Matches方法遍历所有匹配项，并输出到控制台。

运行以上代码，输出结果如下：

匹配到数据: Name=lyshark;
匹配到时间: 86
匹配到时间: 97
匹配到时间: 99
匹配到时间: 50

第一个示例匹配到了字符串Name=lyshark;，第二个示例匹配到了多个以19开头的两位数。

通过这两个示例可以看出，正则表达式可以通过设定匹配条件，对字符串进行灵活的匹配和提取操作。在C#中，可以使用Regex类及其相关方法进行正则表达式的操作。

正则替换字符

代码示例使用了C#中的正则表达式（Regex）类来进行字符串匹配和替换操作。

在示例中，首先导入了System.Text.RegularExpressions命名空间，然后定义了一个Program类。在Main方法中，使用正则表达式进行匹配和替换的操作。

第一个示例演示了使用正则表达式匹配字符串并进行替换的过程。通过创建一个Regex对象，并传入匹配条件Name=(.+);，然后使用Regex.Replace方法将匹配到的部分替换为指定的字符串。最后输出替换后的结果。

第二个示例展示了使用正则表达式替换多余空格的过程。通过创建一个Regex对象，并传入匹配模式\\s+，该模式表示匹配多个连续的空格。然后使用Regex.Replace方法将匹配到的多余空格替换为单个空格。最后输出替换后的结果。

这些示例演示了C#中使用正则表达式进行字符串匹配和替换的基本用法。正则表达式提供了强大的模式匹配功能，可用于处理复杂的字符串操作。

replace 在指定的输入字符串内，使用指定的替换字符串替换与某个正则表达式模式匹配的所有字符串。

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // 正则替换掉指定单词
            string line = "Address=192.168.1.10;  Name=lyshark;";
            Regex reg_line = new Regex("Name=(.+);");
            string modified = reg_line.Replace(line, "Name=admin;");
            Console.WriteLine("修改后的结果:  " + modified);

            // 正则替换掉多余空格
            string input = "Hello    World     ";
            string pattern = "\\s+";
            string replacement = " ";

            Regex reg = new Regex(pattern);
            string result = reg.Replace(input, replacement);

            Console.WriteLine("替换前:{0} 替换后:{1}", input, result);

            Console.ReadKey();
        }
    }
}

判断字符串状态

代码示例展示了使用正则表达式（Regex）类在C#中进行字符串匹配的示例。

在示例中，首先导入了System.Text.RegularExpressions命名空间，然后定义了一个Program类。在Main方法中，使用正则表达式进行字符串匹配的操作。

第一个示例演示了使用正则表达式判断字符串是否完全由0-9的数字组成。通过定义匹配模式为^[0-9]+$，表示字符串的开始和结束必须为数字，并且匹配整个字符串。然后使用Regex.IsMatch方法进行匹配判断，返回结果表示是否匹配成功。

第二个示例展示了使用正则表达式判断字符串中是否包含数字。通过定义匹配模式为\d+，表示匹配任意位子包含一个或多个数字的部分。然后使用Regex.IsMatch方法进行匹配判断，返回结果表示是否匹配成功。

第三个示例展示了使用正则表达式判断字符串开头或结尾是否匹配指定的模式，并忽略大小写。通过定义匹配模式为Hello[\w\W]*，表示匹配以"Hello"开头的字符串（不区分大小写）。然后使用Regex.IsMatch方法进行匹配判断，返回结果表示是否匹配成功。

这些示例演示了C#中使用正则表达式进行字符串匹配的基本用法。正则表达式提供了强大的模式匹配功能，可用于处理各种字符串匹配需求。

IsMatch 指示 Regex 构造函数中指定的正则表达式在指定的输入字符串中是否找到了匹配项。

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string RegexStr = string.Empty;
            // 匹配字符串的开始和结束是否为0-9的数字[定位字符]
            RegexStr = "^[0-9]+$";
            Console.WriteLine("判断是否为数字: {0}", Regex.IsMatch("1234", RegexStr));

            // 匹配字符串中间是否包含数字(任意位子只要有一个数字即可)
            RegexStr = @"\d+";
            Console.WriteLine("判断是否包含数字: {0}", Regex.IsMatch("你好123", RegexStr));

            // 匹配字符串开头结尾,忽略大小写
            RegexStr = @"Hello[\w\W]*";
            Console.WriteLine("匹配是否以Hello开头: {0}", Regex.IsMatch("Hello Lyshark", RegexStr, RegexOptions.IgnoreCase));

            RegexStr = @"[\w\W*]Hello";
            Console.WriteLine("匹配是否已Hello结尾: {0}", Regex.IsMatch("Hello Lyshark", RegexStr, RegexOptions.IgnoreCase));

            Console.ReadKey();
        }
    }
}

正则分组匹配

代码示例展示了在C#中使用正则表达式进行字符串匹配的进阶用法。

在示例中，首先导入了System.Text.RegularExpressions命名空间，然后定义了一个Program类。在Main方法中，使用正则表达式进行字符串匹配的操作。

第一个示例演示了使用正则表达式匹配HTML标签中的属性值。通过定义匹配模式为<a[^>]+href="(\S+)"[^>]+title="([\s\S]+?)"[^>]+>(\S+)</a>，表示匹配包含<a>标签的字符串，并提取href、title和标签内的文本。然后使用Regex.Match方法进行匹配，并通过Match.Groups属性获取匹配结果的各个分组。通过遍历Groups集合，可以获取匹配结果的每个分组值。

第二个示例展示了使用正则表达式进行分组匹配。通过定义匹配模式为姓名:(?<name>[\S]+)\|性别:(?<sex>[\S]{1})\|出生日期:(?<Birth>[\S]{10})\|手机:(?<phone>[\d]{11})，表示匹配一段字符串中的姓名、性别、出生日期和手机号码，并使用命名捕获组指定每个分组的名称。然后使用Regex.Match方法进行匹配，并通过Match.Groups属性和分组名称获取匹配结果的对应分组值。

这些示例展示了使用正则表达式在C#中进行字符串匹配的高级用法，包括提取特定模式的字符串、分组匹配以及使用命名捕获组获取匹配结果的指定分组值。正则表达式在处理复杂字符串匹配需求时非常有用，可以灵活应对各种情况。

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string RegexStr = string.Empty;

            // 匹配所行记录数
            string TaobaoLink = "<a href=\"http://www.taobao.com\" title=\"淘宝网\" target=\"_blank\">淘宝</a>";
            RegexStr = @"<a[^>]+href=""(\S+)""[^>]+title=""([\s\S]+?)""[^>]+>(\S+)</a>";
            
            Match mat = Regex.Match(TaobaoLink, RegexStr);
            for (int i = 0; i < mat.Groups.Count; i++)
            {
                Console.WriteLine(mat.Groups[i].Value);
            }

            // 分组匹配
            string Resume = "姓名:lyshark|性别:男|出生日期:1991-12-12|手机:18264855695";
            RegexStr = @"姓名:(?<name>[\S]+)\|性别:(?<sex>[\S]{1})\|出生日期:(?<Birth>[\S]{10})\|手机:(?<phone>[\d]{11})";
            Match match = Regex.Match(Resume, RegexStr);
            Console.WriteLine("姓名：{0} 手机号: {1}", match.Groups["name"].ToString(),match.Groups["phone"].ToString());

            Console.ReadKey();
        }
    }
}

正则拆分字符串

代码示例展示了在C#中使用正则表达式进行字符串分割的用法。

在示例中，导入了System.Text.RegularExpressions命名空间，并定义了一个Program类。在Main方法中，使用正则表达式进行字符串分割的操作。

首先，定义了要进行分割的输入字符串SplitInputStr，其格式为"数字内容.数字内容.数字内容.数字内容."。

然后，定义了用于分割的正则表达式(\d)，表示匹配任意数字。

接下来，使用Regex类的构造函数将正则表达式传入，创建了一个Regex对象split_exp。

最后，使用split_exp.Split(SplitInputStr)方法对输入字符串进行分割，并将分割结果存储在字符串数组str中。

最后，通过foreach循环遍历str数组，逐行输出分割后的字符串结果。

这个示例展示了使用正则表达式进行字符串分割的用法。通过定义匹配模式并使用Regex.Split方法，可以根据匹配的模式将字符串分割成多个部分，提取出需要的内容。正则表达式的强大特性能够灵活应对各种分割需求，对于处理复杂的字符串分割场景非常有帮助。

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string SplitInputStr = "1xxxxx.2ooooo.3eeee.4kkkkkk.";
            string RegexStr = string.Empty;

            RegexStr = @"(\d)";
            Regex split_exp = new Regex(RegexStr);
            string[] str = split_exp.Split(SplitInputStr);

            foreach (string each in str)
                Console.WriteLine(each);

            Console.ReadKey();
        }
    }
}

解析HTML标签

代码示例展示了在C#中使用正则表达式进行匹配的用法。

在示例中，导入了System.Text.RegularExpressions命名空间，并定义了一个Program类。在Main方法中，使用正则表达式进行匹配操作。

首先，定义了要匹配的字符串LinkA和LinkB，分别表示包含链接的HTML标签和包含标题的HTML标签。

然后，定义了多个正则表达式的模式，用于匹配不同的字符串模式。

通过Regex.Match方法传入字符串和正则表达式模式，进行匹配操作，并将匹配结果存储在Match对象中。

通过match.Value获取匹配结果的值，并输出到控制台。

这个示例展示了使用正则表达式进行字符串匹配的用法。通过定义匹配模式并使用Regex.Match方法，可以对字符串进行复杂的匹配操作，提取出需要的内容。正则表达式的强大特性能够灵活应对各种匹配需求，对于处理复杂的字符串匹配场景非常有帮助。

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            // 获得href中的值
            string RegexStr = string.Empty;

            string LinkA = "<a href=\"http://www.baidu.com\" target=\"_blank\">百度</a>";
            RegexStr = @"href=""[\S]+""";
            Match match = Regex.Match(LinkA, RegexStr);
            Console.WriteLine("获得href中的值: {0}", match.Value);

            // 匹配标签
            string LinkB = "<h1>hellolyshark</h1>";
            RegexStr = @"<h[^23456]>[\S]+</h[1]>";
            Console.WriteLine("h1值: {0}", Regex.Match(LinkB, RegexStr, RegexOptions.IgnoreCase).Value);



            RegexStr = @"ab\w+|ij\w{1,}";   //匹配ab和字母 或 ij和字母
            Console.WriteLine("{0}。多选结构：{1}", "abcd", Regex.Match("abcd", RegexStr).Value);
            Console.WriteLine("{0}。多选结构：{1}", "efgh", Regex.Match("efgh", RegexStr).Value);
            Console.WriteLine("{0}。多选结构：{1}", "ijk", Regex.Match("ijk", RegexStr).Value);



            RegexStr = @"张三?丰";    //?匹配前面的子表达式零次或一次。
            Console.WriteLine("{0}。可选项元素：{1}", "张三丰", Regex.Match("张三丰", RegexStr).Value);
            Console.WriteLine("{0}。可选项元素：{1}", "张丰", Regex.Match("张丰", RegexStr).Value);
            Console.WriteLine("{0}。可选项元素：{1}", "张飞", Regex.Match("张飞", RegexStr).Value);

            //匹配特殊字符
            RegexStr = @"Asp\.net";    //匹配Asp.net字符，因为.是元字符他会匹配除换行符以外的任意字符。
            Console.WriteLine("{0}。匹配Asp.net字符：{1}", "Java Asp.net SQLServer", Regex.Match("Java Asp.net", RegexStr).Value);
            Console.WriteLine("{0}。匹配Asp.net字符：{1}", "C# Java", Regex.Match("C# Java", RegexStr).Value);


            Console.ReadKey();
        }
    }
}