.NET正则表达式的最佳用法

using system;
using system.diagnostics;
using system.text.regularexpressions;

public class example
{
   public static void main()
   {
      stopwatch sw;
      string[] addresses = { "aaaaaaaaaaa@contoso.com",
                             "aaaaaaaaaaaaaaaaaaaa!@contoso.com" };
      // the following regular expression should not actually be used to
      // validate an email address.
      string pattern = @"^[0-9a-z]([-.\w]*[0-9a-z])*$";
      string input;

      foreach (var address in addresses) {
         string mailbox = address.substring(0, address.indexof("@"));
         int index = 0;
         for (int ctr = mailbox.length - 1; ctr >= 0; ctr--) {
            index++;

            input = mailbox.substring(ctr, index);
            sw = stopwatch.startnew();
            match m = regex.match(input, pattern, regexoptions.ignorecase);
            sw.stop();
            if (m.success)
               console.writeline("{0,2}. matched '{1,25}' in {2}",
                                 index, m.value, sw.elapsed);
            else
               console.writeline("{0,2}. failed  '{1,25}' in {2}",
                                 index, input, sw.elapsed);
         }
         console.writeline();
      }
   }
}

// the example displays output similar to the following:
//     1. matched '                        a' in 00:00:00.0007122
//     2. matched '                       aa' in 00:00:00.0000282
//     3. matched '                      aaa' in 00:00:00.0000042
//     4. matched '                     aaaa' in 00:00:00.0000038
//     5. matched '                    aaaaa' in 00:00:00.0000042
//     6. matched '                   aaaaaa' in 00:00:00.0000042
//     7. matched '                  aaaaaaa' in 00:00:00.0000042
//     8. matched '                 aaaaaaaa' in 00:00:00.0000087
//     9. matched '                aaaaaaaaa' in 00:00:00.0000045
//    10. matched '               aaaaaaaaaa' in 00:00:00.0000045
//    11. matched '              aaaaaaaaaaa' in 00:00:00.0000045
//
//     1. failed  '                        !' in 00:00:00.0000447
//     2. failed  '                       a!' in 00:00:00.0000071
//     3. failed  '                      aa!' in 00:00:00.0000071
//     4. failed  '                     aaa!' in 00:00:00.0000061
//     5. failed  '                    aaaa!' in 00:00:00.0000081
//     6. failed  '                   aaaaa!' in 00:00:00.0000126
//     7. failed  '                  aaaaaa!' in 00:00:00.0000359
//     8. failed  '                 aaaaaaa!' in 00:00:00.0000414
//     9. failed  '                aaaaaaaa!' in 00:00:00.0000758
//    10. failed  '               aaaaaaaaa!' in 00:00:00.0001462
//    11. failed  '              aaaaaaaaaa!' in 00:00:00.0002885
//    12. failed  '             aaaaaaaaaaa!' in 00:00:00.0005780
//    13. failed  '            aaaaaaaaaaaa!' in 00:00:00.0011628
//    14. failed  '           aaaaaaaaaaaaa!' in 00:00:00.0022851
//    15. failed  '          aaaaaaaaaaaaaa!' in 00:00:00.0045864
//    16. failed  '         aaaaaaaaaaaaaaa!' in 00:00:00.0093168
//    17. failed  '        aaaaaaaaaaaaaaaa!' in 00:00:00.0185993
//    18. failed  '       aaaaaaaaaaaaaaaaa!' in 00:00:00.0366723
//    19. failed  '      aaaaaaaaaaaaaaaaaa!' in 00:00:00.1370108
//    20. failed  '     aaaaaaaaaaaaaaaaaaa!' in 00:00:00.1553966
//    21. failed  '    aaaaaaaaaaaaaaaaaaaa!' in 00:00:00.3223372

public void okbutton_click(object sender, eventargs e)
{
   if (! string.isnullorempty(sourcecurrency.text))
      if (regexlib.isvalidcurrency(sourcecurrency.text))
         performconversion();
      else
         status.text = "the source currency value is invalid.";
}

using system;
using system.text.regularexpressions;

public class regexlib
{
   public static bool isvalidcurrency(string currencyvalue)
   {
      string pattern = @"\p{sc}+\s*\d+";
      regex currencyregex = new regex(pattern);
      return currencyregex.ismatch(currencyvalue);
   }
}

using system;
using system.text.regularexpressions;

public class regexlib
{
   public static bool isvalidcurrency(string currencyvalue)
   {
      string pattern = @"\p{sc}+\s*\d+";
      return regex.ismatch(currencyvalue, pattern);
   }
}

using system;
using system.diagnostics;
using system.io;
using system.text.regularexpressions;

public class example
{
   public static void main()
   {
      string pattern = @"\b(\w+((\r?\n)|,?\s))*\w+[.?:;!]";
      stopwatch sw;
      match match;
      int ctr;

      streamreader infile = new streamreader(@".\dreiser_thefinancier.txt");
      string input = infile.readtoend();
      infile.close();

      // read first ten sentences with interpreted regex.
      console.writeline("10 sentences with interpreted regex:");
      sw = stopwatch.startnew();
      regex int10 = new regex(pattern, regexoptions.singleline);
      match = int10.match(input);
      for (ctr = 0; ctr <= 9; ctr++) {
         if (match.success)
            // do nothing with the match except get the next match.
            match = match.nextmatch();
         else
            break;
      }
      sw.stop();
      console.writeline("   {0} matches in {1}", ctr, sw.elapsed);

      // read first ten sentences with compiled regex.
      console.writeline("10 sentences with compiled regex:");
      sw = stopwatch.startnew();
      regex comp10 = new regex(pattern,
                   regexoptions.singleline | regexoptions.compiled);
      match = comp10.match(input);
      for (ctr = 0; ctr <= 9; ctr++) {
         if (match.success)
            // do nothing with the match except get the next match.
            match = match.nextmatch();
         else
            break;
      }
      sw.stop();
      console.writeline("   {0} matches in {1}", ctr, sw.elapsed);

      // read all sentences with interpreted regex.
      console.writeline("all sentences with interpreted regex:");
      sw = stopwatch.startnew();
      regex intall = new regex(pattern, regexoptions.singleline);
      match = intall.match(input);
      int matches = 0;
      while (match.success) {
         matches++;
         // do nothing with the match except get the next match.
         match = match.nextmatch();
      }
      sw.stop();
      console.writeline("   {0:n0} matches in {1}", matches, sw.elapsed);

      // read all sentences with compiled regex.
      console.writeline("all sentences with compiled regex:");
      sw = stopwatch.startnew();
      regex compall = new regex(pattern,
                      regexoptions.singleline | regexoptions.compiled);
      match = compall.match(input);
      matches = 0;
      while (match.success) {
         matches++;
         // do nothing with the match except get the next match.
         match = match.nextmatch();
      }
      sw.stop();
      console.writeline("   {0:n0} matches in {1}", matches, sw.elapsed);
   }
}
// the example displays the following output:
//       10 sentences with interpreted regex:
//          10 matches in 00:00:00.0047491
//       10 sentences with compiled regex:
//          10 matches in 00:00:00.0141872
//       all sentences with interpreted regex:
//          13,443 matches in 00:00:01.1929928
//       all sentences with compiled regex:
//          13,443 matches in 00:00:00.7635869
//
//       >compare1
//       10 sentences with interpreted regex:
//          10 matches in 00:00:00.0046914
//       10 sentences with compiled regex:
//          10 matches in 00:00:00.0143727
//       all sentences with interpreted regex:
//          13,443 matches in 00:00:01.1514100
//       all sentences with compiled regex:
//          13,443 matches in 00:00:00.7432921

using system;
using system.reflection;
using system.text.regularexpressions;

public class example
{
   public static void main()
   {
      regexcompilationinfo sentencepattern =
                           new regexcompilationinfo(@"\b(\w+((\r?\n)|,?\s))*\w+[.?:;!]",
                                                    regexoptions.multiline,
                                                    "sentencepattern",
                                                    "utilities.regularexpressions",
                                                    true);
      regexcompilationinfo[] regexes = { sentencepattern };
      assemblyname assemname = new assemblyname("regexlib, version=1.0.0.1001, culture=neutral, publickeytoken=null");
      regex.compiletoassembly(regexes, assemname);
   }
}

using system;
using system.io;
using system.text.regularexpressions;
using utilities.regularexpressions;

public class example
{
   public static void main()
   {
      sentencepattern pattern = new sentencepattern();
      streamreader infile = new streamreader(@".\dreiser_thefinancier.txt");
      string input = infile.readtoend();
      infile.close();

      matchcollection matches = pattern.matches(input);
      console.writeline("found {0:n0} sentences.", matches.count);
   }
}
// the example displays the following output:
//      found 13,443 sentences.

using system;
using system.text.regularexpressions;

public class example
{
   public static void main()
   {
      string input = "this this word sentence name capital";
      string pattern = @"\b\p{lu}\w*\b";
      foreach (match match in regex.matches(input, pattern))
         console.writeline(match.value);

      console.writeline();

      pattern = @"\b\p{lu}(?>\w*)\b";
      foreach (match match in regex.matches(input, pattern))
         console.writeline(match.value);
   }
}
// the example displays the following output:
//       this
//       sentence
//       capital
//
//       this
//       sentence
//       capital

using system;
using system.text.regularexpressions;

public class example
{
   public static void main()
   {
      string pattern = @"^[0-9a-z][-.\w]*(?<=[0-9a-z])\$$";
      string[] partnos = { "a1c$", "a4", "a4$", "a1603d$", "a1603d#" };

      foreach (var input in partnos) {
         match match = regex.match(input, pattern);
         if (match.success)
            console.writeline(match.value);
         else
            console.writeline("match not found.");
      }
   }
}
// the example displays the following output:
//       a1c$
//       match not found.
//       a4$
//       a1603d$
//       match not found.

using system;
using system.collections.generic;
using system.io;
using system.text.regularexpressions;

public class example
{
   public static void main()
   {
      regexutilities util = new regexutilities();
      string title = "doyle - the hound of the baskervilles.txt";
      try {
         var info = util.getworddata(title);
         console.writeline("words:               {0:n0}", info.item1);
         console.writeline("average word length: {0:n2} characters", info.item2);
      }
      catch (ioexception e) {
         console.writeline("ioexception reading file '{0}'", title);
         console.writeline(e.message);
      }
      catch (regexmatchtimeoutexception e) {
         console.writeline("the operation timed out after {0:n0} milliseconds",
                           e.matchtimeout.totalmilliseconds);
      }
   }
}

public class regexutilities
{
   public tuple<int, double> getworddata(string filename)
   {
      const int max_timeout = 1000;   // maximum timeout interval in milliseconds.
      const int increment = 350;      // milliseconds increment of timeout.

      list<string> exclusions = new list<string>( new string[] { "a", "an", "the" });
      int[] wordlengths = new int[29];        // allocate an array of more than ample size.
      string input = null;
      streamreader sr = null;
      try {
         sr = new streamreader(filename);
         input = sr.readtoend();
      }
      catch (filenotfoundexception e) {
         string msg = string.format("unable to find the file '{0}'", filename);
         throw new ioexception(msg, e);
      }
      catch (ioexception e) {
         throw new ioexception(e.message, e);
      }
      finally {
         if (sr != null) sr.close();
      }

      int timeoutinterval = increment;
      bool init = false;
      regex rgx = null;
      match m = null;
      int indexpos = 0;
      do {
         try {
            if (! init) {
               rgx = new regex(@"\b\w+\b", regexoptions.none,
                               timespan.frommilliseconds(timeoutinterval));
               m = rgx.match(input, indexpos);
               init = true;
            }
            else {
               m = m.nextmatch();
            }
            if (m.success) {
               if ( !exclusions.contains(m.value.tolower()))
                  wordlengths[m.value.length]++;

               indexpos += m.length + 1;
            }
         }
         catch (regexmatchtimeoutexception e) {
            if (e.matchtimeout.totalmilliseconds < max_timeout) {
               timeoutinterval += increment;
               init = false;
            }
            else {
               // rethrow the exception.
               throw;
            }
         }
      } while (m.success);

      // if regex completed successfully, calculate number of words and average length.
      int nwords = 0;
      long totallength = 0;

      for (int ctr = wordlengths.getlowerbound(0); ctr <= wordlengths.getupperbound(0); ctr++) {
         nwords += wordlengths[ctr];
         totallength += ctr * wordlengths[ctr];
      }
      return new tuple<int, double>(nwords, totallength/nwords);
   }
}

using system;
using system.text.regularexpressions;

public class example
{
   public static void main()
   {
      string input = "this is one sentence. this is another.";
      string pattern = @"\b(\w+[;,]?\s?)+[.?!]";

      foreach (match match in regex.matches(input, pattern)) {
         console.writeline("match: '{0}' at index {1}.",
                           match.value, match.index);
         int grpctr = 0;
         foreach (group grp in match.groups) {
            console.writeline("   group {0}: '{1}' at index {2}.",
                              grpctr, grp.value, grp.index);
            int capctr = 0;
            foreach (capture cap in grp.captures) {
               console.writeline("      capture {0}: '{1}' at {2}.",
                                 capctr, cap.value, cap.index);
               capctr++;
            }
            grpctr++;
         }
         console.writeline();
      }
   }
}
// the example displays the following output:
//       match: 'this is one sentence.' at index 0.
//          group 0: 'this is one sentence.' at index 0.
//             capture 0: 'this is one sentence.' at 0.
//          group 1: 'sentence' at index 12.
//             capture 0: 'this ' at 0.
//             capture 1: 'is ' at 5.
//             capture 2: 'one ' at 8.
//             capture 3: 'sentence' at 12.
//
//       match: 'this is another.' at index 22.
//          group 0: 'this is another.' at index 22.
//             capture 0: 'this is another.' at 22.
//          group 1: 'another' at index 30.
//             capture 0: 'this ' at 22.
//             capture 1: 'is ' at 27.
//             capture 2: 'another' at 30.

using system;
using system.text.regularexpressions;

public class example
{
   public static void main()
   {
      string input = "this is one sentence. this is another.";
      string pattern = @"\b(?:\w+[;,]?\s?)+[.?!]";

      foreach (match match in regex.matches(input, pattern)) {
         console.writeline("match: '{0}' at index {1}.",
                           match.value, match.index);
         int grpctr = 0;
         foreach (group grp in match.groups) {
            console.writeline("   group {0}: '{1}' at index {2}.",
                              grpctr, grp.value, grp.index);
            int capctr = 0;
            foreach (capture cap in grp.captures) {
               console.writeline("      capture {0}: '{1}' at {2}.",
                                 capctr, cap.value, cap.index);
               capctr++;
            }
            grpctr++;
         }
         console.writeline();
      }
   }
}
// the example displays the following output:
//       match: 'this is one sentence.' at index 0.
//          group 0: 'this is one sentence.' at index 0.
//             capture 0: 'this is one sentence.' at 0.
//
//       match: 'this is another.' at index 22.
//          group 0: 'this is another.' at index 22.
//             capture 0: 'this is another.' at 22.