DotNet里的RegExp

JS有RE
JAVA也有
.NET也有

JAVA最清楚,就两个类,全部搞定
.NET弄了一堆,不知道做些什么,随便了解一下
感觉肯定是比JAVA要简单,容易实现高功能的
但是没有时间了

○一二三四五六七八九○一二三四五六七八九○一二三四五六七八九○一二三四五六七八九

System.Text.RegularExpressions 命名空间
10个类
这些类提供对 .NET Framework 正则表达式引擎的访问

1类

   Capture
   表示单个子表达式捕获中的结果。
   Capture 表示单个成功捕获中的一个子字符串。

   该对象是不可变的，并且没有公共构造函数。
   实例通过 Captures 返回的集合返回。Match 和 Group 类扩展 Capture。[看下面就知道了]
   就是说这个类没有什么用的,就把他当临时变量放放东西好了.

举个例子好了:
================================================================================
    class Program
    {
        static void Main(string[] args)
        {
            //看清楚空格
            string text = "One car red car blue car";

            //'?<1>'这个东西我猜是给()取名字而已
            //整个的意思是:必须有字符,然后必须要空格,必须有car,car后有没有空格无所谓
            //测试过了,对这个pattern的分析是非常对的
            string pat = @"(?<1>\w+)\s+(?<2>car)\s*";

            // 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);

            //找到了
            while (m.Success)
            {
                // Display the first match and its capture set.
                System.Console.WriteLine("Match=[" + m + "]");
                CaptureCollection cc = m.Captures;
                foreach (Capture c in cc)
                {
                    System.Console.WriteLine("Capture=[" + c + "]");
                }


                // Display Group1 and its capture set.
                Group g1 = m.Groups[1];
                System.Console.WriteLine("Group1=[" + g1 + "]");
                foreach (Capture c1 in g1.Captures)
                {
                    System.Console.WriteLine("Capture1=[" + c1 + "]");
                }
                // Display Group2 and its capture set.
                Group g2 = m.Groups[2];
                System.Console.WriteLine("Group2=[" + g2 + "]");
                foreach (Capture c2 in g2.Captures)
                {
                    System.Console.WriteLine("Capture2=[" + c2 + "]");
                }
                // Advance to the next match.
                m = m.NextMatch();
                System.Console.WriteLine("one match over!");
                System.Console.WriteLine();
            }
          
        }
    }

================================================================================
Match=[One car ]
Capture=[One car ]
Group1=[One]
Capture1=[One]
Group2=[car]
Capture2=[car]
one match over!

Match=[red car ]
Capture=[red car ]
Group1=[red]
Capture1=[red]
Group2=[car]
Capture2=[car]
one match over!

Match=[blue car]
Capture=[blue car]
Group1=[blue]
Capture1=[blue]
Group2=[car]
Capture2=[car]
one match over!

请按任意键继续. . .

就说这一个"One car red car blue car"里
有三次和我的pattern匹配了
而且每次匹配都把好东西拿到了
可以放在Match m 里
然后
CaptureCollection cc = m.Captures;
foreach (Capture c in cc)
拿东西所有的东西

还可以一小点一小点拿
Group g1 = m.Groups[1];
================================================================================


2类
   CaptureCollection 表示一个捕获子字符串序列。
   CaptureCollection 返回由单个捕获组执行的捕获的集合。
   该集合是不可变（只读）的，并且没有公共构造函数。实例在 Captures 集合中返回。
   CaptureCollection cc = m.Captures;

3类
   Group
   Group 表示单个捕获组的结果。由于存在数量词，
   一个捕获组可以在单个匹配中捕获零个、一个或更多的字符串，
   因此 Group 提供 Capture 对象的集合。
================================================================================
    class Program
    {
        static void Main(string[] args)
        {
            string text = "One car red car blue car";
           
            //一个match里有多个group的
            string pat = @"(\w+)\s+(car)";
           
            // 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)
            {
                //先说说是第几个找到匹配pattern的
                Console.WriteLine("Match" + (++matchCount));
               
                for (int i = 1; i <= 2; i++)
                {
                    //一个match里有多个group的,这里hardcode了2是pattern里就有二个
                    Group g = m.Groups[i];
                    Console.WriteLine("Group" + i + "='" + g + "'");
                    CaptureCollection cc = g.Captures;
                    //不怕这个loop,count都是1
                    for (int j = 0; j < cc.Count; j++)
                    {
                        Capture c = cc[j];
                        System.Console.WriteLine(
                            "Capture" + j + "='" + c + "', Position=" + c.Index);
                    }
                }
                Console.WriteLine();
                m = m.NextMatch();

            }
        }
    }
----------------------------------------
Match1
Group1='One'
Capture0='One', Position=0
Group2='car'
Capture0='car', Position=4

Match2
Group1='red'
Capture0='red', Position=8
Group2='car'
Capture0='car', Position=12

Match3
Group1='blue'
Capture0='blue', Position=16
Group2='car'
Capture0='car', Position=21

请按任意键继续. . .
================================================================================

4类
   GroupCollection 表示捕获组的集合。GroupCollection 返回单个匹配中的捕获组的集合。
   该集合是不可变（只读）的，并且没有公共构造函数。实例在由 Groups 返回的集合中返回

5类
   Match 表示单个正则表达式匹配的结果。
   由于单个匹配可能涉及多个捕获组，
   因此 Match 具有返回 GroupCollection 的 Groups 属性。
   GroupCollection 具有返回每个组的访问器。
   Match 从 Group 继承，因此可以直接访问匹配的整个子字符串。
   也就是说，Match 实例自身等效于 Match.Groups[0]（Visual Basic 中则为 Match.Groups(0)）。
   Match 对象是不可变的，并且没有公共构造函数。

6类
   MatchCollection 表示通过以迭代方式将正则表达式模式应用于输入字符串所找到的成功匹配的集合。
   该集合是不可变（只读）的，并且没有公共构造函数。实例通过 Matches 方法返回。
   注意如何使用 (?<word>) 构造来命名组，以及稍后如何使用 (\k<word>) 在表达式中引用该组。
================================================================================
    class Program
    {
        static void Main(string[] args)
        {
            // Define a regular expression for repeated words.
            Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
              RegexOptions.Compiled | RegexOptions.IgnoreCase);

            // Define a test string.       
            string text = "The the quick brown fox  fox jumped over the lazy dog dog.";

            // Find matches.
            MatchCollection matches = rx.Matches(text);

            // Report the number of matches found.
            Console.WriteLine("{0} matches found.", matches.Count);

            // Report on each match.
            foreach (Match match in matches)
            {
                string word = match.Groups["word"].Value;
                int index = match.Index;
                Console.WriteLine("{0} repeated at position {1}", word, index);
            }
        }
    }
----------------------------------------
3 matches found.
The repeated at position 0
fox repeated at position 20
dog repeated at position 50
请按任意键继续. . .

================================================================================

7类
   Regex 表示不可变的正则表达式。
   这个类估计是最最重要的了
   下面简单演示怎么用RE来检查一个 会计的 数字
   注意，如果使用 ^ 和 $ 封闭标记，
   则指示整个字符串（而不只是子字符串）都必须匹配正则表达式。

================================================================================
    class Program
    {
        static void Main(string[] args)
        {
            // Define a regular expression for currency values.
            Regex rx = new Regex(@"^-?\d+(\.\d{2})?$");

            // Define some test strings.
            string[] tests = { "-42", "19.99", "0.001", "100 USD" };

            // Check each test string against the regular expression.
            foreach (string test in tests)
            {
                if (rx.IsMatch(test))
                {
                    Console.WriteLine("{0} is a currency value.", test);
                }
                else
                {
                    Console.WriteLine("{0} is not a currency value.", test);
                }
            }

        }
    }
----------------------------------------
-42 is a currency value.
19.99 is a currency value.
0.001 is not a currency value.
100 USD is not a currency value.
请按任意键继续. . .
================================================================================



8类
RegexCompilationInfo 提供编译器用于将正则表达式编译为独立程序集的信息。
这个太高深了,算了,我是做JAVA的

下面也是,没有必要弄的那么清楚,否则一事无成!

RegexRunner RegexRunner 类是编译正则表达式的基类。
RegexRunnerFactory 为编译过的正则表达式创建 RegexRunner 类。

委托
MatchEvaluator 表示在 Replace 方法操作过程中每当找到正则表达式匹配时都调用的方法。

枚举
RegexOptions 提供用于设置正则表达式选项的枚举值。
这个再来说一下东西
--------------------------------------------------------------------------------
// Define a regular expression for repeated words.
Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
  RegexOptions.Compiled | RegexOptions.IgnoreCase);

--------------------------------------------------------------------------------
比如上面这个就用了 两个值
他们的意思是:

Compiled
指定将正则表达式编译为程序集。这会产生更快的执行速度，但会增加启动时间。 

CultureInvariant 指定忽略语言中的区域性差异。
有关更多信息，请参见在 RegularExpressions 命名空间中执行不区分区域性的操作。 

ECMAScript 为表达式启用符合 ECMAScript 的行为。
该值只能与 IgnoreCase、Multiline 和 Compiled 值一起使用。
该值与其他任何值一起使用均将导致异常。 

ExplicitCapture 指定有效的捕获仅为形式为 (?<name>...) 的显式命名或编号的组。
这使未命名的圆括号可以充当非捕获组，并且不会使表达式的语法 (?:...) 显得笨拙。 

IgnoreCase 指定不区分大小写的匹配。 

IgnorePatternWhitespace 消除模式中的非转义空白并启用由 # 标记的注释。
但是，IgnorePatternWhitespace 值不会影响或消除字符类中的空白。  

Multiline 多行模式。更改 ^ 和 $ 的含义，使它们分别在任意一行的行首和行尾匹配，
而不仅仅在整个字符串的开头和结尾匹配。 

None 指定不设置选项。 

RightToLeft 指定搜索从右向左而不是从左向右进行。 

Singleline 指定单行模式。更改点 (.) 的含义，
使它与每一个字符匹配（而不是与除 \n 之外的每个字符匹配）。 

看了这个,是不是觉得复杂有复杂的好处,微软就是微软