引言

    正则表达式（regular expression）就是用一个“字符串”来描述一个特征，然后去验证另一个“字符串”是否符合这个特征。比如 表达式“ab+” 描述的特征是“一个 'a' 和 任意个 'b' ”，那么 'ab', 'abb', 'abbbbbbbbbb' 都符合这个特征。

    正则表达式可以用来：（1）验证字符串是否符合指定特征，比如验证是否是合法的邮件地址。（2）用来查找字符串，从一个长的文本中查找符合指定特征的字符串，比查找固定字符串更加灵活方便。（3）用来替换，比普通的替换更强大。

   正则表达式学习起来其实是很简单的，不多的几个较为抽象的概念也很容易理解。之所以很多人感觉正则表达式比较复杂，一方面是因为大多数的文档没有做到由浅入深地讲解，概念上没有注意先后顺序，给读者的理解带来困难；另一方面，各种引擎自带的文档一般都要介绍它特有的功能，然而这部分特有的功能并不是我们首先要理解的。

    文章中的每一个举例，都可以点击进入到测试页面进行测试。闲话少说，开始。

1. 正则表达式规则

1.1 普通字符

    字母、数字、汉字、下划线、以及后边章节中没有特殊定义的标点符号，都是"普通字符"。表达式中的普通字符，在匹配一个字符串的时候，匹配与之相同的一个字符。

    举例1：表达式 "c"，在匹配字符串 "abcde" 时，匹配结果是：成功；匹配到的内容是："c"；匹配到的位置是：开始于2，结束于3。（注：下标从0开始还是从1开始，因当前编程语言的不同而可能不同）

    举例2：表达式 "bcd"，在匹配字符串 "abcde" 时，匹配结果是：成功；匹配到的内容是："bcd"；匹配到的位置是：开始于1，结束于4。

1.2 简单的转义字符

    一些不便书写的字符，采用在前面加 "\" 的方法。这些字符其实我们都已经熟知了。

    还有其他一些在后边章节中有特殊用处的标点符号，在前面加 "\" 后，就代表该符号本身。比如：^, $ 都有特殊意义，如果要想匹配字符串中 "^" 和 "$" 字符，则表达式就需要写成 "\^" 和 "\$"。

    这些转义字符的匹配方法与 "普通字符" 是类似的。也是匹配与之相同的一个字符。

    举例1：表达式 "\$d"，在匹配字符串 "abc$de" 时，匹配结果是：成功；匹配到的内容是："$d"；匹配到的位置是：开始于3，结束于5。

1.3 能够与 '多种字符' 匹配的表达式

    正则表达式中的一些表示方法，可以匹配 '多种字符' 其中的任意一个字符。比如，表达式 "\d" 可以匹配任意一个数字。虽然可以匹配其中任意字符，但是只能是一个，不是多个。这就好比玩扑克牌时候，大小王可以代替任意一张牌，但是只能代替一张牌。

    举例1：表达式 "\d\d"，在匹配 "abc123" 时，匹配的结果是：成功；匹配到的内容是："12"；匹配到的位置是：开始于3，结束于5。

    举例2：表达式 "a.\d"，在匹配 "aaa100" 时，匹配的结果是：成功；匹配到的内容是："aa1"；匹配到的位置是：开始于1，结束于4。

1.4 自定义能够匹配 '多种字符' 的表达式

    使用方括号 [ ] 包含一系列字符，能够匹配其中任意一个字符。用 [^ ] 包含一系列字符，则能够匹配其中字符之外的任意一个字符。同样的道理，虽然可以匹配其中任意一个，但是只能是一个，不是多个。

    举例1：表达式 "[bcd][bcd]" 匹配 "abc123" 时，匹配的结果是：成功；匹配到的内容是："bc"；匹配到的位置是：开始于1，结束于3。

    举例2：表达式 "[^abc]" 匹配 "abc123" 时，匹配的结果是：成功；匹配到的内容是："1"；匹配到的位置是：开始于3，结束于4。

1.5 修饰匹配次数的特殊符号

    前面章节中讲到的表达式，无论是只能匹配一种字符的表达式，还是可以匹配多种字符其中任意一个的表达式，都只能匹配一次。如果使用表达式再加上修饰匹配次数的特殊符号，那么不用重复书写表达式就可以重复匹配。

    使用方法是："次数修饰"放在"被修饰的表达式"后边。比如："[bcd][bcd]" 可以写成 "[bcd]{2}"。

    举例1：表达式 "\d+\.?\d*" 在匹配 "It costs $12.5" 时，匹配的结果是：成功；匹配到的内容是："12.5"；匹配到的位置是：开始于10，结束于14。

    举例2：表达式 "go{2,8}gle" 在匹配 "Ads by goooooogle" 时，匹配的结果是：成功；匹配到的内容是："goooooogle"；匹配到的位置是：开始于7，结束于17。

1.6 其他一些代表抽象意义的特殊符号

    一些符号在表达式中代表抽象的特殊意义：

    进一步的文字说明仍然比较抽象，因此，举例帮助大家理解。

    举例1：表达式 "^aaa" 在匹配 "xxx aaa xxx" 时，匹配结果是：失败。因为 "^" 要求与字符串开始的地方匹配，因此，只有当 "aaa" 位于字符串的开头的时候，"^aaa" 才能匹配，比如："aaa xxx xxx"。

    举例2：表达式 "aaa$" 在匹配 "xxx aaa xxx" 时，匹配结果是：失败。因为 "$" 要求与字符串结束的地方匹配，因此，只有当 "aaa" 位于字符串的结尾的时候，"aaa$" 才能匹配，比如："xxx xxx aaa"。

    举例3：表达式 ".\b." 在匹配 "@@@abc" 时，匹配结果是：成功；匹配到的内容是："@a"；匹配到的位置是：开始于2，结束于4。
    进一步说明："\b" 与 "^" 和 "$" 类似，本身不匹配任何字符，但是它要求它在匹配结果中所处位置的左右两边，其中一边是 "\w" 范围，另一边是 非"\w" 的范围。

    举例4：表达式 "\bend\b" 在匹配 "weekend,endfor,end" 时，匹配结果是：成功；匹配到的内容是："end"；匹配到的位置是：开始于15，结束于18。

    一些符号可以影响表达式内部的子表达式之间的关系：

    举例5：表达式 "Tom|Jack" 在匹配字符串 "I'm Tom, he is Jack" 时，匹配结果是：成功；匹配到的内容是："Tom"；匹配到的位置是：开始于4，结束于7。匹配下一个时，匹配结果是：成功；匹配到的内容是："Jack"；匹配到的位置时：开始于15，结束于19。

    举例6：表达式 "(go\s*)+" 在匹配 "Let's go go go!" 时，匹配结果是：成功；匹配到内容是："go go go"；匹配到的位置是：开始于6，结束于14。

    举例7：表达式 "￥(\d+\.?\d*)" 在匹配 "＄10.9,￥20.5" 时，匹配的结果是：成功；匹配到的内容是："￥20.5"；匹配到的位置是：开始于6，结束于10。单独获取括号范围匹配到的内容是："20.5"。

2. 正则表达式中的一些高级规则

2.1 匹配次数中的贪婪与非贪婪

    在使用修饰匹配次数的特殊符号时，有几种表示方法可以使同一个表达式能够匹配不同的次数，比如："{m,n}", "{m,}", "?", "*", "+"，具体匹配的次数随被匹配的字符串而定。这种重复匹配不定次数的表达式在匹配过程中，总是尽可能多的匹配。比如，针对文本 "dxxxdxxxd"，举例如下：

    由此可见，"\w+" 在匹配的时候，总是尽可能多的匹配符合它规则的字符。虽然第二个举例中，它没有匹配最后一个 "d"，但那也是为了让整个表达式能够匹配成功。同理，带 "*" 和 "{m,n}" 的表达式都是尽可能地多匹配，带 "?" 的表达式在可匹配可不匹配的时候，也是尽可能的 "要匹配"。这 种匹配原则就叫作 "贪婪" 模式 。

    非贪婪模式：

    在修饰匹配次数的特殊符号后再加上一个 "?" 号，则可以使匹配次数不定的表达式尽可能少的匹配，使可匹配可不匹配的表达式，尽可能的 "不匹配"。这种匹配原则叫作 "非贪婪" 模式，也叫作 "勉强" 模式。如果少匹配就会导致整个表达式匹配失败的时候，与贪婪模式类似，非贪婪模式会最小限度的再匹配一些，以使整个表达式匹配成功。举例如下，针对文本 "dxxxdxxxd" 举例：

    更多的情况，举例如下：

    举例1：表达式 "<td>(.*)</td>" 与字符串 "<td><p>aa</p></td> <td><p>bb</p></td>" 匹配时，匹配的结果是：成功；匹配到的内容是 "<td><p>aa</p></td> <td><p>bb</p></td>" 整个字符串， 表达式中的 "</td>" 将与字符串中最后一个 "</td>" 匹配。

    举例2：相比之下，表达式 "<td>(.*?)</td>" 匹配举例1中同样的字符串时，将只得到 "<td><p>aa</p></td>"， 再次匹配下一个时，可以得到第二个 "<td><p>bb</p></td>"。

2.2 反向引用 \1, \2...

    表达式在匹配时，表达式引擎会将小括号 "( )" 包含的表达式所匹配到的字符串记录下来。在获取匹配结果的时候，小括号包含的表达式所匹配到的字符串可以单独获取。这一点，在前面的举例中，已经多次展示了。在实际应用场合中，当用某种边界来查找，而所要获取的内容又不包含边界时，必须使用小括号来指定所要的范围。比如前面的 "<td>(.*?)</td>"。

    其实，"小括号包含的表达式所匹配到的字符串" 不仅是在匹配结束后才可以使用，在匹配过程中也可以使用。表达式后边的部分，可以引用前面 "括号内的子匹配已经匹配到的字符串"。引用方法是 "\" 加上一个数字。"\1" 引用第1对括号内匹配到的字符串，"\2" 引用第2对括号内匹配到的字符串……以此类推，如果一对括号内包含另一对括号，则外层的括号先排序号。换句话说，哪一对的左括号 "(" 在前，那这一对就先排序号。

    举例如下：

    举例1：表达式 "('|")(.*?)(\1)" 在匹配 " 'Hello', "World" " 时，匹配结果是：成功；匹配到的内容是：" 'Hello' "。再次匹配下一个时，可以匹配到 " "World" "。

    举例2：表达式 "(\w)\1{4,}" 在匹配 "aa bbbb abcdefg ccccc 111121111 999999999" 时，匹配结果是：成功；匹配到的内容是 "ccccc"。再次匹配下一个时，将得到 999999999。这个表达式要求 "\w" 范围的字符至少重复5次，注意与 "\w{5,}" 之间的区别。

    举例3：表达式 "<(\w+)\s*(\w+(=('|").*?\4)?\s*)*>.*?</\1>" 在匹配 "<td id='td1' style="bgcolor:white"></td>" 时，匹配结果是成功。如果 "<td>" 与 "</td>" 不配对，则会匹配失败；如果改成其他配对，也可以匹配成功。

2.3 预搜索，不匹配；反向预搜索，不匹配

    前面的章节中，我讲到了几个代表抽象意义的特殊符号："^"，"$"，"\b"。它们都有一个共同点，那就是：它们本身不匹配任何字符，只是对 "字符串的两头" 或者 "字符之间的缝隙" 附加了一个条件。理解到这个概念以后，本节将继续介绍另外一种对 "两头" 或者 "缝隙" 附加条件的，更加灵活的表示方法。

    正向预搜索："(?=xxxxx)"，"(?!xxxxx)"

    格式："(?=xxxxx)"，在被匹配的字符串中，它对所处的 "缝隙" 或者 "两头" 附加的条件是：所在缝隙的右侧，必须能够匹配上 xxxxx 这部分的表达式。因为它只是在此作为这个缝隙上附加的条件，所以它并不影响后边的表达式去真正匹配这个缝隙之后的字符。这就类似 "\b"，本身不匹配任何字符。"\b" 只是将所在缝隙之前、之后的字符取来进行了一下判断，不会影响后边的表达式来真正的匹配。

    举例1：表达式 "Windows (?=NT|XP)" 在匹配 "Windows 98, Windows NT, Windows 2000" 时，将只匹配 "Windows NT" 中的 "Windows "，其他的 "Windows " 字样则不被匹配。

    举例2：表达式 "(\w)((?=\1\1\1)(\1))+" 在匹配字符串 "aaa ffffff 999999999" 时，将可以匹配6个"f"的前4个，可以匹配9个"9"的前7个。这个表达式可以读解成：重复4次以上的字母数字，则匹配其剩下最后2位之前的部分。当然，这个表达式可以不这样写，在此的目的是作为演示之用。

    格式："(?!xxxxx)"，所在缝隙的右侧，必须不能匹配 xxxxx 这部分表达式。

    举例3：表达式 "((?!\bstop\b).)+" 在匹配 "fdjka ljfdl stop fjdsla fdj" 时，将从头一直匹配到 "stop" 之前的位置，如果字符串中没有 "stop"，则匹配整个字符串。

    举例4：表达式 "do(?!\w)" 在匹配字符串 "done, do, dog" 时，只能匹配 "do"。在本条举例中，"do" 后边使用 "(?!\w)" 和使用 "\b" 效果是一样的。

    反向预搜索："(?<=xxxxx)"，"(?<!xxxxx)"

    这两种格式的概念和正向预搜索是类似的，反向预搜索要求的条件是：所在缝隙的 "左侧"，两种格式分别要求必须能够匹配和必须不能够匹配指定表达式，而不是去判断右侧。与 "正向预搜索" 一样的是：它们都是对所在缝隙的一种附加条件，本身都不匹配任何字符。

    举例5：表达式 "(?<=\d{4})\d+(?=\d{4})" 在匹配 "1234567890123456" 时，将匹配除了前4个数字和后4个数字之外的中间8个数字。由于 JScript.RegExp 不支持反向预搜索，因此，本条举例不能够进行演示。很多其他的引擎可以支持反向预搜索，比如：Java 1.4 以上的 java.util.regex 包，.NET 中System.Text.RegularExpressions 命名空间，以及本站推荐的最简单易用的 DEELX 正则引擎。

3. 其他通用规则

    还有一些在各个正则表达式引擎之间比较通用的规则，在前面的讲解过程中没有提到。

3.1 表达式中，可以使用 "\xXX" 和 "\uXXXX" 表示一个字符（"X" 表示一个十六进制数）

3.2 在表达式 "\s"，"\d"，"\w"，"\b" 表示特殊意义的同时，对应的大写字母表示相反的意义

3.3 在表达式中有特殊意义，需要添加 "\" 才能匹配该字符本身的字符汇总

3.4 括号 "( )" 内的子表达式，如果希望匹配结果不进行记录供以后使用，可以使用 "(?:xxxxx)" 格式

    举例1：表达式 "(?:(\w)\1)+" 匹配 "a bbccdd efg" 时，结果是 "bbccdd"。括号 "(?:)" 范围的匹配结果不进行记录，因此 "(\w)" 使用 "\1" 来引用。

3.5 常用的表达式属性设置简介：Ignorecase，Singleline，Multiline，Global

4. 其他提示

4.1 如果想要了解高级的正则引擎还支持那些复杂的正则语法，可参见本站 DEELX 正则引擎的说明文档。

4.2 如果要要求表达式所匹配的内容是整个字符串，而不是从字符串中找一部分，那么可以在表达式的首尾使用 "^" 和 "$"，比如："^\d+$" 要求整个字符串只有数字。

4.3 如果要求匹配的内容是一个完整的单词，而不会是单词的一部分，那么在表达式首尾使用 "\b"，比如：使用 "\b(if|while|else|void|int……)\b" 来匹配程序中的关键字。

4.4 表达式不要匹配空字符串。否则会一直得到匹配成功，而结果什么都没有匹配到。比如：准备写一个匹配 "123"、"123."、"123.5"、".5" 这几种形式的表达式时，整数、小数点、小数数字都可以省略，但是不要将表达式写成："\d*\.?\d*"，因为如果什么都没有，这个表达式也可以匹配成功。更好的写法是："\d+\.?\d*|\.\d+"。

4.5 能匹配空字符串的子匹配不要循环无限次。如果括号内的子表达式中的每一部分都可以匹配 0 次，而这个括号整体又可以匹配无限次，那么情况可能比上一条所说的更严重，匹配过程中可能死循环。虽然现在有些正则表达式引擎已经通过办法避免了这种情况出现死循环了，比如 .NET 的正则表达式，但是我们仍然应该尽量避免出现这种情况。如果我们在写表达式时遇到了死循环，也可以从这一点入手，查找一下是否是本条所说的原因。

4.6 合理选择贪婪模式与非贪婪模式，参见话题讨论。

4.7 或 "|" 的左右两边，对某个字符最好只有一边可以匹配，这样，不会因为 "|" 两边的表达式因为交换位置而有所不同。

评论: 0　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· Notifo推iPhone应用：弥补邮件推送缺陷(2010-03-19 21:04)
· 分析：微软IE9现身 网络视频标准争议依旧未解(2010-03-19 20:57)
· 连线朱骏：陈晓薇离开九城与魔兽无关(2010-03-19 20:52)
· 九城总裁陈晓薇5月期满离任 朱骏将代理总裁(2010-03-19 20:48)
· Google携手Intel和Sony推出"Google电视"(2010-03-19 20:44)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

正则表达式(regular expression)对象包含一个正则表达式模式(pattern)。它具有用正则表达式模式去匹配或代替一个串(string)中特定字符(或字符集合)的属性(properties)和方法(methods)。

正则表达式构造函数： new RegExp("pattern"[,"flags"]);
参数说明：
pattern -- 一个正则表达式文本
flags -- 如果存在，将是以下值：
g: 全局匹配
i: 忽略大小写
gi: 以上组合

在构造函数中，一些特殊字符需要进行转意(在特殊字符前加"\")。正则表达式中的特殊字符： 
\ 转意，即通常在"\"后面的字符不按原来意义解释，如/b/匹配字符"b"，当b前面加了反斜杆后/\b/，转意为匹配一个单词的边界。
-或-
对正则表达式功能字符的还原，如"*"匹配它前面元字符0次或多次，/a*/将匹配a,aa,aaa，加了"\"后，/a\*/ 将只匹配"a*"。  ^  匹配一个输入或一行的开头，/^a/匹配"an A"，而不匹配"An a" 
$  匹配一个输入或一行的结尾，/a$/匹配"An a"，而不匹配"an A" 
*  匹配前面元字符0次或多次，/ba*/将匹配b,ba,baa,baaa 
+  匹配前面元字符1次或多次，/ba*/将匹配ba,baa,baaa 
?  匹配前面元字符0次或1次，/ba*/将匹配b,ba 
(x)  匹配x保存x在名为$1...$9的变量中 
x|y  匹配x或y 
{n}  精确匹配n次 
{n,}  匹配n次以上 
{n,m}  匹配n-m次 
[xyz]  字符集(character set)，匹配这个集合中的任一一个字符(或元字符) 
[^xyz]  不匹配这个集合中的任何一个字符 
[\b]  匹配一个退格符
\b  匹配一个单词的边界 
\B  匹配一个单词的非边界
\cX  这儿，X是一个控制符，/\cM/匹配Ctrl-M 
\d  匹配一个字数字符，/\d/ = /[0-9]/ 
\D  匹配一个非字数字符，/\D/ = /[^0-9]/ 
\n  匹配一个换行符 
\r  匹配一个回车符 
\s  匹配一个空白字符，包括\n,\r,\f,\t,\v等 
\S  匹配一个非空白字符，等于/[^\n\f\r\t\v]/ 
\t  匹配一个制表符 
\v  匹配一个重直制表符 
\w  匹配一个可以组成单词的字符(alphanumeric，这是我的意译，含数字)，包括下划线，如[\w]匹配"$5.98"中的5，等于[a-zA-Z0-9] 
\W  匹配一个不可以组成单词的字符，如[\W]匹配"$5.98"中的$，等于[^a-zA-Z0-9]。

说了这么多了，我们来看一些正则表达式的实际应用的例子：
HTML代码的屏蔽
 function mask_HTMLCode(strInput) {
   var myReg = /<(\w+)>/;
   return strInput.replace(myReg, "&lt;$1&gt;");
 }
E-mail地址验证:
 function test_email(strEmail) {
  var myReg = /^[_a-z0-9]+@([_a-z0-9]+\.)+[a-z0-9]{2,3}$/;
  if(myReg.test(strEmail)) return true;
  return false;
 }

正则表达式对象的属性及方法：
预定义的正则表达式拥有有以下静态属性：input, multiline, lastMatch, lastParen, leftContext,rightContext和$1到$9。其中input和multiline可以预设置。其他属性的值在执行过exec或 test方法后被根据不同条件赋以不同的值。许多属性同时拥有长和短(perl风格)的两个名字，并且，这两个名字指向同一个值。(

JavaScript模拟perl的正则表达式)
正则表达式对象的属性：
属性 含义
$1...$9 如果它(们)存在，是匹配到的子串 
$_ 参见input 
$* 参见multiline 
$& 参见lastMatch 
$+ 参见lastParen 
$` 参见leftContext 
$''　　　　　　　　　 参见rightContext 
constructor　　　  创建一个对象的一个特殊的函数原型 
global　　　　　　  是否在整个串中匹配(bool型) 
ignoreCase　　　　 匹配时是否忽略大小写(bool型) 
input　　　　　　　 被匹配的串 
lastIndex　　　　  最后一次匹配的索引 
lastParen　　　　  最后一个括号括起来的子串 
leftContext　　　  最近一次匹配以左的子串 
multiline　　　　  是否进行多行匹配(bool型) 
prototype　　　　  允许附加属性给对象 
rightContext　　　 最近一次匹配以右的子串 
source　　　　　　  正则表达式模式 
lastIndex　　　　  最后一次匹配的索引 

正则表达式对象的方法：
方法 含义
compile　　　　　  正则表达式比较 
exec　　　　　　　 执行查找 
test　　　　　　　 进行匹配 
toSource　　　　　 返回特定对象的定义(literal

representing)，其值可用来创建一个新的对象。重载Object.toSource方法得到的。 
toString　　　　　 返回特定对象的串。重载Object.toString方法得到的。 
valueOf　　　　　  返回特定对象的原始值。重载Object.valueOf方法得到 

例子
<script language = "JavaScript"> 
var myReg = /(w+)s(w+)/; 
var str  = "John Smith"; 
var newstr = str.replace(myReg, "$2, $1"); 
document.write(newstr); 
</script> 
将输出"Smith, John" 

常用的js正则表达式

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=879180

评论: 0　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· Notifo推iPhone应用：弥补邮件推送缺陷(2010-03-19 21:04)
· 分析：微软IE9现身 网络视频标准争议依旧未解(2010-03-19 20:57)
· 连线朱骏：陈晓薇离开九城与魔兽无关(2010-03-19 20:52)
· 九城总裁陈晓薇5月期满离任 朱骏将代理总裁(2010-03-19 20:48)
· Google携手Intel和Sony推出"Google电视"(2010-03-19 20:44)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

转自http://hi.baidu.com/76512/blog/item/2064fc245c42ca368744f94b.html

老郁闷，今天本来想继续把未完的ASP系统写完，本地浏览，出现了“常见错误   不能打开注册表关键字”等的提示，因为前两天是正常的，不可能是数据库连结语句出现问题，想着应该是IIS出错了。

       于是，重启了IIS，问题依旧……上网查找相关问题，好多同学重装了机器，这让我有点晕，不如重装IIS好了，控制面板中添加删除组件，再次安装，毛病更大了，出现了“Server Application Error”的提示，本来可以显示HTML页面的，现在统统成了：

Server Application Error
The server has encountered an error while loading an application during the processing of your request. Please refer to the event log for more detail information. Please contact the server administrator for assistance.

       网上教了一种方法可以解决这个问题，多是文字表述，搞得我2个多钟头才弄明白，还是掐几张图和大家共勉一下吧。

        在我的电脑上点鼠标右键，选择管理。

       在计算机管理点事件查看器中的应用程序，如果你发现MSDTC错误的话，嘿嘿，也许你就不用象我这么麻烦了，其实要是我在重新安装IIS之前看一眼的话，我也不用麻烦了……怪我水平高精尖的不算！双击错误提示，打开对话框：

      告诉俺这是缺少了一个日志文件，所以没启动成MSDTC服务，可以运行msdtc -resetlog来创建这个日志文件，鬼知道这MSDTC是什么服务，如果你这是这种情况，可以创建文件后启动MSDTC服务，试验一下ASP网页文件能否打开。我就没这么幸运，因为我自找的把麻烦升级了，看后文吧～

        在计算机管理点服务和应用程序中的服务，右侧就出现计算机的服务列表，出问题时你找不到“distributed transaction coordinator”这项服务的，嘿嘿，这是我启动MSDTC后才出现的服务，它的主要作用大家可以看上图中的描述部分，如何启动它，别急，先让我解决我的问题才说。

       在计算机管理点本地用户和组中的用户，右侧出现系统的用户列表，不好意思，我把我的用户名字马赛克了，我们要给IUSR_机器名和IWAM_机器名两个用户改密码，记得改成一样的密码。右键单击IUSR_机器名，菜单第一项就是更改密码，点击后：

     当然是继续了，不能被这长篇大论给吓回去。

      密码设置成“123456”吧，用同样的方法给IWAM_机器名也设置一下。点击开始，运行，输入“CMD”回车。

       打开DOS窗口，输入“cd C:\Inetpub\AdminScripts”，大家可以根据系统安装盘符替换：

      呵呵，下面是这个目录的文件列表，反正也不清楚都是做什么用的……

       接着输入“cscript.exe adsutil.vbs set w3svc/wamuserpass 123456”，你可以替换123456为你刚才在计算机管理处设置的密码，一定要一样的。

       接着输入“cscript.exe adsutil.vbs set w3svc/anonymoususerpass 123456”，同样的，也要和上面设置的密码一样。

出现上面图中的提示，说明设置密码成功了；再同步系统密码，我们输入：“cscript.exe synciwam.vbs -v”。

       多数可能就此通过，系统正常了，但俺很不幸，最下边一行出现了“Error:8004E00F”的错误提示，本人这时候才知道是MSDTC没有正常启动的原因……

       于是我在DOS窗口中输入“net stop msdtc”看是否启动了该项服务，出现下图状况：

      说是系统没有启动MSDTC，俺先用“msdtc -uninstall”卸了它，再用“msdtc-install”重新装上，再用“msdtc -resetlog”创建日志文件，最后用“net start msdtc”启动服务，成功。同步系统密码吧，输入：“cscript.exe synciwam.vbs -v”再回车。

       没错误，去试一下ASP页面是否能成功打开？也许你们的都可以了，可俺还是不行……最后一招，注册相关组件。在DOS窗口，输入“cd windows\system32\inetsrv ”，进入系统文件夹的inetsrv目录。

       然后输入“rundll32 wamreg.dll, CreateIISPackage”

       最后输入“regsvr32 asptxn.dll ”

      可算是成了，两个钟头过去了……给大家分享一下，同志们下次就用不着两钟头了，也许十几分钟就搞定～需要提醒的是，在DOS窗口输入完命令记得回车哦！

       网友甲：GHOST重装系统也不过5分钟！

       网友乙：这还用教？简单到死……

       网友丙：还是没看明白！

       本人很无语……

评论: 0　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· Notifo推iPhone应用：弥补邮件推送缺陷(2010-03-19 21:04)
· 分析：微软IE9现身 网络视频标准争议依旧未解(2010-03-19 20:57)
· 连线朱骏：陈晓薇离开九城与魔兽无关(2010-03-19 20:52)
· 九城总裁陈晓薇5月期满离任 朱骏将代理总裁(2010-03-19 20:48)
· Google携手Intel和Sony推出"Google电视"(2010-03-19 20:44)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

1、正则表达式简介 　　正则表达式提供了功能强大、灵活而又高效的方法来处理文本。正则表达式的全面模式匹配表示法可以快速地分析大量的文本以找到特定的字符模式；提取、编辑、替换或删除文本子字符串；或将提取的字符串添加到集合以生成报告。对于处理字符串（例如 HTML 处理、日志文件分析和 HTTP 标头分析）的许多应用程序而言，正则表达式是不可缺少的工具。  　　.NET 框架正则表达式并入了其他正则表达式实现的最常见功能，被设计为与 Perl 5 正则表达式兼容，.NET 框架正则表达式还包括一些在其他实现中尚未提供的功能，.NET 框架正则表达式类是基类库的一部分，并且可以和面向公共语言运行库的任何语言或工具一起使用。 　　2、字符串搜索 　　正则表达式语言由两种基本字符类型组成：原义（正常）文本字符和元字符。正是元字符组为正则表达式提供了处理能力。当前，所有的文本编辑器都有一些搜索功能，通常可以打开一个对话框，在其中的一个文本框中键入要定位的字符串，如果还要同时进行替换操作，可以键入一个替换字符串，比如在Windows操作系统中的记事本、Office系列中的文档编辑器都有这种功能。这种搜索最简单的方式，这类问题很容易用String类的String.Replace()方法来解决，但如果需要在文档中识别某个重复的，该怎么办？编写一个例程，从一个String类中选择重复的字是比较复杂的，此时使用语言就很适合。 　　一般表达式语言是一种可以编写搜索表达式的语言。在该语言中，可以把文档中要搜索的文本、转义序列和特定含义的其他字符组合在一起，例如序列\b表示一个字的开头和结尾（子的边界），如果要表示正在查找的以字符th开头的字，就可以编写一般表达式\bth（即序列字符界是-t-h）。如果要搜索所有以th结尾的字，就可以编写th\b（序列t-h-字边界）。但是，一般表达式要比这复杂得多，例如，可以在搜索操作中找到存储部分文本的工具性程序（facility）。 　　3、.NET 框架的正则表达式类 　　下面通过介绍 .NET 框架的正则表达式类，熟悉一下.NET框架下的正则表达式的使用方法。 　　3.1 Regex 类表示只读正则表达式 　　Regex 类包含各种静态方法，允许在不显式实例化其他类的对象的情况下使用其他正则表达式类。以下代码示例创建了 Regex 类的实例并在初始化对象时定义一个简单的正则表达式。请注意，使用了附加的反斜杠作为转义字符，它将 \s 匹配字符类中的反斜杠指定为原义字符。 Regex r; // 声明一个 Regex类的变量 r = new Regex("\\s2000"); // 定义表达式 　　3.2 Match 类表示正则表达式匹配操作的结果 　　以下示例使用 Regex 类的 Match 方法返回 Match 类型的对象，以便找到输入字符串中第一个匹配。此示例使用 Match 类的 Match.Success 属性来指示是否已找到匹配。 Regex r = new Regex("abc"); // 定义一个Regex对象实例 Match m = r.Match("123abc456"); // 在字符串中匹配 if (m.Success)  { 　Console.WriteLine("Found match at position " + m.Index); //输入匹配字符的位置 } 　　3.3 MatchCollection 类表示非重叠匹配的序列 　　该集合为只读的，并且没有公共构造函数。MatchCollection 的实例是由 Regex.Matches 属性返回的。使用 Regex 类的 Matches 方法，通过在输入字符串中找到的所有匹配填充 MatchCollection。下面代码示例演示了如何将集合复制到一个字符串数组（保留每一匹配）和一个整数数组（指示每一匹配的位置）中。 MatchCollection mc; String[] results = new String[20]; int[] matchposition = new int[20]; Regex r = new Regex("abc"); //定义一个Regex对象实例 mc = r.Matches("123abc4abcd");  for (int i = 0; i < mc.Count; i++) //在输入字符串中找到所有匹配 { 　results[i] = mc[i].Value; //将匹配的字符串添在字符串数组中 　matchposition[i] = mc[i].Index; //记录匹配字符的位置 } 　　3.4 GroupCollection 类表示捕获的组的集合 　　该集合为只读的，并且没有公共构造函数。GroupCollection 的实例在 Match.Groups 属性返回的集合中返回。下面的控制台应用程序查找并输出由正则表达式捕获的组的数目。  using System; using System.Text.RegularExpressions; public class RegexTest  { 　public static void RunTest()  　{ 　　Regex r = new Regex("(a(b))c"); //定义组 　　Match m = r.Match("abdabc"); 　　Console.WriteLine("Number of groups found = " + m.Groups.Count); 　} 　public static void Main()  　{ 　　RunTest(); 　} } 　　该示例产生下面的输出： Number of groups found = 3 　　3.5 CaptureCollection 类表示捕获的子字符串的序列  　　由于限定符，捕获组可以在单个匹配中捕获多个字符串。Captures属性（CaptureCollection 类的对象）是作为 Match 和 group 类的成员提供的，以便于对捕获的子字符串的集合的访问。例如，如果使用正则表达式 ((a(b))c)+（其中 + 限定符指定一个或多个匹配）从字符串"abcabcabc"中捕获匹配，则子字符串的每一匹配的 Group 的 CaptureCollection 将包含三个成员。 　　下面的程序使用正则表达式 (Abc)+来查找字符串"XYZAbcAbcAbcXYZAbcAb"中的一个或多个匹配，阐释了使用 Captures 属性来返回多组捕获的子字符串。  using System; using System.Text.RegularExpressions; public class RegexTest  { 　public static void RunTest()  　{ 　　int counter; 　　Match m; 　　CaptureCollection cc; 　　GroupCollection gc; 　　Regex r = new Regex("(Abc)+"); //查找"Abc" 　　m = r.Match("XYZAbcAbcAbcXYZAbcAb"); //设定要查找的字符串 　　gc = m.Groups; 　　//输出查找组的数目 　　Console.WriteLine("Captured groups = " + gc.Count.ToString());  　　// Loop through each group. 　　for (int i=0; i < gc.Count; i++) //查找每一个组 　　{ 　　　cc = gc[i].Captures; 　　　counter = cc.Count; 　　　Console.WriteLine("Captures count = " + counter.ToString()); 　　　for (int ii = 0; ii < counter; ii++)  　　　{ 　　　　// Print capture and position. 　　　　Console.WriteLine(cc[ii] + " Starts at character " +  　　　　cc[ii].Index); //输入捕获位置 　　　} 　　} 　} 　public static void Main() { 　　RunTest(); 　} } 　　此例返回下面的输出结果： Captured groups = 2 Captures count = 1 AbcAbcAbc Starts at character 3 Captures count = 3 Abc Starts at character 3 Abc Starts at character 6 Abc Starts at character 9 　　3.6 Capture 类包含来自单个子表达式捕获的结果 　　在 Group 集合中循环，从 Group 的每一成员中提取 Capture 集合，并且将变量 posn 和 length 分别分配给找到每一字符串的初始字符串中的字符位置，以及每一字符串的长度。 Regex r; Match m; CaptureCollection cc; int posn, length; r = new Regex("(abc)*"); m = r.Match("bcabcabc"); for (int i=0; m.Groups[i].Value != ""; i++)  { 　cc = m.Groups[i].Captures;  　for (int j = 0; j < cc.Count; j++)  　{ 　　posn = cc[j].Index; //捕获对象位置 　　length = cc[j].Length; //捕获对象长度 　} } 图1：对象关系 　　把组合字符组合起来后，每次都会返回一个组对象，就可能并不是我们希望的结果。如果希望把组合字符作为搜索模式的一部分，就会有相当大的系统开销。对于单个的组，可以用以字符序列"?:"开头的组禁止这么做，就像URI样例那样。而对于所有的组，可以在RegEx.Matches()方法上指定RegExOptions.ExplicitCapture标志。 　　4、利用正则表达式实现字符串搜索 　　4.1 在C#中使用.NET一般表达式引擎 　　下面将通过一个样例的开发，执行并显示一些搜索的结果，说明一般表达式的一些特性，以及如何在C#中使用.NET一般表达式引擎。说明使用字符串时应在前面加上符号@。 String Text=@"I can not find my position in Beijing"; 　　把这个文本称为输入字符串，为了说明一般表达式.NET类，本文先进行一次纯文本的搜索，这次搜索不带任何转义序列或一般表达式命令。假定要查找所有字符串ion，把这个搜索字符串称为模式。使用一般表达式和上面声明的变量Text，编写出下面的代码： String Pattern = "ion"; MatchCollection Matches = Regex.Matches(Text,Pattern,RegexOptions); foreach(Match NextMatch in Matches) { Console.WriteLine(NextMatch.Index); } 　　在这段代码中，使用了System.Text.RegularExpressions名称空间中Regex类的静态方法Match()。这个方法的参数是一些输入文本、一个模式和RegexOptions每句中的一组可选标志。Matches()返回MatchCollection，每个匹配都用一个Match对象来表示。在上面的代码中，只是在集合中迭代，使用Match类的Index属性，返回输入文本中匹配所在的索引。运行这段代码，将得到1个匹配项。 　　一般集合的功能主要取决于模式字符串。原因是模式字符串不仅仅包含纯文本。如前所述。还包含元字符和转义序列，元字符是给出命令的特殊字符，而转义序列的工作方式与C#的转义序列相同，它们都是以反斜杠\开头的字符，具有特殊的含义。例如，假定要查找以n开头的字，就可以使用转义序列\b，它表示一个字的边界（字的边界是以某个字母数字标的字符开头，或者后面是一个空白字符或标点符号），下面编写如下代码：  String Pattern = @"\bn"; MatchCollection Matches = Regex.Matches(Text,Pattern,RegexOptions.IgnoreCase| RegexOptions.ExplicitCapture); 　　要在运行时把\b传递给.NET一般表达式引擎，反斜杠\不应被C#编译器解释为转义序列。如果要查找以序列ion结尾的字，可以使用下面的代码： String Pattern = @"ion\b"; 　　如果要查找以字母n开头，以序列ion结尾的所有字，需要一个以\bn开头，以ion\b结尾的模式，中间内容怎么办？需要告诉计算机n和ion中间的内容可以是任意长度的字符，只要字符不是空白即可，正确的模式如下所示： String Pattern = @"\bn\S*ion\b"; 　　4.2 特定字符或转义序列 　　大多数重要的正则表达式语言运算符都是非转义的单个字符。转义符 \（单个反斜杠）通知正则表达式分析器反斜杠后面的字符不是运算符。例如，分析器将星号 (*) 视为重复限定符，而将后跟星号的反斜杠 (\*) 视为 Unicode 字符 002A。 　　使用一般表达式要习惯的一点是，查看像这样怪异的字符序列，但这个序列的工作是非常逻辑化的。转义序列\S表示任何不适空白的字符。*称为数量词，其含义是前面的字符可以重复任意次，包括0次。序列\S*表示任何不适空白的字符。因此，上面的模式匹配于以n开头，以ion结尾的任何单个字。下表中列出的字符转义在正则表达式和替换模式中都会被识别。 　　表1：特定字符或转义序列 特定字符或转义序列 含义 样例  匹配的样例 ^  输入文本的开头 ^B  B，但只能是文本中的第一个字符 $  输入文本的结尾 X$ X，但只能是文本中的最后一个字符 .  除了换行字符（\n）以外的所有单个字符 i.ation isation、ization *  可以重复0次或多次的前导字符 ra*t rat、raat等 +  可以重复1次或多次的前导字符 ra+t rt、rat、raat等 ？ 可以重复0次或1次的前导字符 ra?t  只有rt和rat匹配 \s  任何空白字符  \sa  [space]a,\ta,\na（\t和\n与C#的\t和\n含义相同） \S  任何不是空白的字符 \SF aF,rF,cF，但不能是\tf \b  字边界 ion\b 以ion结尾的任何字 \B  不是字边界的位置  \BX\B  字中间的任何X 　　如果要搜索一个元字符，也可以通过带有反斜杠的转义字符来表示。例如，.表示除了换行字符以外的任何字符，而\.表示一个点。 可以把可替换的字符放在方括号中，请求匹配包含这些字符。例如，[1|c]表示字符可以是1或者是c。如果要搜索map或者man，可以使用序列"ma[n|p]"（仅指引号内字符，下面雷同）。在方括号中，也可以制定一个范围，例如"[a-z]"表示所有的小写字母（使用连字号 (-) 允许指定连续字符范围），"[B-F]"表示B到F之间的所有大写字母，"[0-9]"表示一个数字，如果要搜索一个整数（该序列只包含0到9的字符），就可以编写"[0-9]+"（注意，使用+字符表示至少要有这样一个数字，但可以有多个数字，所以9、83和3443等都是匹配的。） 下面看看一般表达式的结果，编写一个实例RegularExpressionsZzy。建立几个一般表达式，显示其结果，让用户了解一下表达式是如何工作的。 　　该实例的核心是一个方法WriteMatches()，它把MatchCollection中的所有匹配以比较详细的方式显示出来。对于每个匹配，它都会显示该匹配在输入字符串中所在的索引，匹配的字符串和一个略长的字符串，其中包含输入文本中至多8个外围字符，其中至少有5个字符放在匹配的前面，至多5个字符放在匹配的后面（如果匹配的位置在输入文本的开头或结尾5个字符内，则结果中匹配前后的字符就会少于4个）。换言之，靠近输入文本末尾的匹配应是"and messaging ofd"，匹配的前后各有5个字符，但位于输入文本的最后一个字上的匹配就应是"g of data"，匹配的字后只有一个字符。因为在该字符的后面是字符串的结尾。这个长字符串可以更清楚地表明一般表达式是在什么地方查找到匹配的： static void WriteMatches(string text, MatchCollection matches) { 　Console.WriteLine("Original text was: \n\n" + text + "\n"); 　Console.WriteLine("No. of matches: " + matches.Count); 　foreach (Match nextMatch in matches) 　{ 　　int Index = nextMatch.Index; 　　string result = nextMatch.ToString(); 　　int charsBefore = (Index < 5) ? Index : 5; 　　int fromEnd = text.Length - Index - result.Length; 　　int charsAfter = (fromEnd < 5) ? fromEnd : 5; 　　int charsToDisplay = charsBefore + charsAfter + result.Length; 　　Console.WriteLine("Index: {0}, \tString: {1}, \t{2}",Index, result,  　　text.Substring(Index - charsBefore, charsToDisplay)); 　} } 　　在这个方法中，处理过程是确定在较长的字符串中有多少个字符可以显示，而无需超限输入文本的开头或结尾。注意在Match对象上使用了另一个属性Value，它包含标识该匹配的字符串，而且，RegularExpressionsZzy只包含名为Find_po，Find_n等的方法，这些方法根据本文执行某些搜索操作。 　　4.3 正则表达式选项 　　可以使用影响匹配行为的选项修改正则表达式模式。可以通过两种基本方法设置正则表达式选项：其一是可以在 Regex(pattern, options) 构造函数中的 options 参数中指定，其中 options 是 RegexOptions 枚举值的按位"或"组合；其二是使用内联 (?imnsx-imnsx:) 分组构造或 (?imnsx-imnsx) 其他构造在正则表达式模式内设置它们。 　　在内联选项构造中，一个选项或一组选项前面的减号 (-) 用于关闭这些选项。例如，内联构造 (?ix-ms) 将打开 IgnoreCase 和 IgnorePatternWhiteSpace 选项而关闭 Multiline 和 Singleline 选项。 　　表2：RegexOptions 枚举的成员以及等效的内联选项字符 RegexOption 成员 内联字符 说明 None  无  指定不设置任何选项。 IgnoreCase i  指定不区分大小写的匹配。 Multiline m  指定多行模式。更改 ^ 和 $ 的含义，以使它们分别与任何行的开头和结尾匹配，而不只是与整个字符串的开头和结尾匹配。 ExplicitCapture n  指定唯一有效的捕获是显式命名或编号的 (?<name>...) 形式的组。这允许圆括号充当非捕获组，从而避免了由 (?:...) 导致的语法上的笨拙。 Compiled 无 指定正则表达式将被编译为程序集。生成该正则表达式的 Microsoft 中间语言 (MSIL) 代码；以较长的启动时间为代价，得到更快的执行速度。  Singleline s  指定单行模式。更改句点字符 (.) 的含义，以使它与每个字符（而不是除 \n 外的所有字符）匹配。 IgnorePatternWhitespace x  指定从模式中排除非转义空白并启用数字符号 (#) 后面的注释。请注意，空白永远不会从字符类中消除。 RightToLeft 无  指定搜索是从右向左而不是从左向右进行的。具有此选项的正则表达式将移动到起始位置的左边而不是右边。（因此，起始位置应指定为字符串的结尾而不是开头。）为了避免构造具有无限循环的正则表达式的可能性，此选项不能在中流指定。但是，(?<) 回顾后发构造提供了可用作子表达式的类似替代物。 ECMAScript  无  指定已为表达式启用了符合 ECMAScript 的行为。此选项仅可与 IgnoreCase 和 Multiline 标志一起使用。将 ECMAScript 同任何其他标志一起使用将导致异常。 　　例如，Find_po在字开头处查找以"po"开头的字符串： static void Find_po() { 　string text = @" I can not find my position in Beijing "; 　string pattern = @"\bpo\S*ion\b"; 　MatchCollection matches = Regex.Matches(text, pattern, RegexOptions.IgnoreCase  | RegexOptions.IgnorePatternWhitespace | RegexOptions.ExplicitCapture); 　WriteMatches(text, matches); } 　　这段代码还使用了名称空间RegularExpressions： using System; using System.Text.RegularExpressions; 　　4.4 匹配、组和捕获 　　一般表达式的一个很好的特性是可以把字符组合起来，方式与C#中的复合语句一样。在C#中，可以通过把任意数量的语句放在花括号中的方式把它们组合在一起。其结果就像一个复合语句那样。在一般表达式模式中，也可以把任何字符组合起来（包括元字符和转义序列），像处理一个字符那样处理它们。唯一的区别是要使用圆括号，而不是花括号，得到的序列成为一个组。  　　例如，模式"(an)+"定位序列an的任以重复。量词+只应用于它前面的一个字符，但因为我们把字符组合起来了，所以它现在把重复的an作为一个单元来对待。"(an)."应用到输入文本"bananas came to Europe late in the annals of history"上，会从bananas中选择出anan。另一方面，如果使用an+，则将从annals中选择ann，从bananas中选择出两个an。为什么(an)+选择的是anan，而没有把单个的an作为一个匹配。匹配规则是不能重复的，如果有可能重复，在默认情况下就选择较长的匹配。 　　但是，组的功能要比这强大得多。在默认情况下，把模式的一部分组合为一个组时，就要求一般表达式引擎记住可以按照这个组来匹配，也可以按照整个模式来匹配。换言之，可以把组当作一个要匹配的模式，如果要把字符串分解为各个部分，这种模式就是非常有效的。  例如，URI的格式是"<protocol>://<address>:<port>"，其中端口是可选的。它的一个样例是http://www.comprg.com.cn:8080。假定要从一个URI中提取协议、地址和端口，而且紧邻URI的后面可能有空白（但没有标点符号），就可以使用下面的表达式："\b(\S+)://(\S+)(?::(\S+))?\b" 　　该表达式的工作方式如下：首先，前导和尾部的\b序列确保只需要考虑完全是字的文本部分，在这个文本部分中，第一组"(\S+)://"会选择一个或多个不适空白的字符，其后是"://"。在HTTPURI的开头会选择出http://。花括号表示把http存储为一个组。后面的"(\S+)"则在上述URI中选择www. comprg.com.cn，这个组在遇到词的结尾时或标记另一个组的冒号"(:)"时结束。 　　下一个组选择端口（本例是:8080）。后面的？表示这个组在匹配中是可选的，如果没有:xxxx，也不会妨碍匹配的标记。 　　这是非常重要的，因为端口在URI中一般不指定，实际上，在大多数情况下，URI是没有端口号的。但是，事情会比较复杂。如果要求冒号可以出现，也可以不出现，但不希望把这个冒号也存储在组中。为此，可以嵌套两个组：内部的"(\S+)"组选择冒号后面的内容（本例中是8080），外面的组包含内部的组，后面是一个冒号，该冒号又在序列"?:"的后面。这个序列表示该组不应保存（只需要保存"8080"，不需要保存":8080"）。不要把这两个冒号混淆了，第一个冒号是序列"?:"的一部分，表示不保存这个组，第二个冒号是要搜索的文本。 　　在这个字符串上运行该模式：I always visit http://www. comprg.com.cn 得到的匹配是http://www. comprg.com.cn。在这个匹配中，仅提到了三个组，还有第四个组表示匹配本身。理论上，每个组都可以选择0次、1次或者多次匹配。单个的匹配就称为捕获。在第一个组"(\S+)"，有一个捕获http。第二个组也有一个捕获www. comprg.com.cn，但第三个组没有捕获，因为在这个URI中没有端口号。注意该字符串在其本身上包含第二个http://。虽然它匹配于第一个组，但不会被搜索出来，因为整个搜索表达式不匹配于这部分文本。 再比如下面这个例子，以下代码示例使用 Match.Result 来从 URL提取协议和端口号。例如，"http://www.yahoo.com.cn:8080/index.html"将返回"http:8080"。 String Extension(String url)  { 　Regex r = new Regex(@"^(?<proto>\w+)://[^/]+?(?<port>:\d+)?/", 　RegexOptions.Compiled); 　return r.Match(url).Result("${proto}${port}");  } 　　5、小结 　　.NET 框架正则表达式类是基类库的一部分，并且可以和面向公共语言运行库的任何语言或工具（包括 ASP.NET 和 Visual Studio .NET）一起使用。本文给出了在C#下利用正则表达式实现字符串搜索功能的方法，通过对.NET框架下的正则表达式的研究及实例分析，总结了正则表达式的规则、选项等，方便以后朋友们的应用。

评论: 0　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· Notifo推iPhone应用：弥补邮件推送缺陷(2010-03-19 21:04)
· 分析：微软IE9现身 网络视频标准争议依旧未解(2010-03-19 20:57)
· 连线朱骏：陈晓薇离开九城与魔兽无关(2010-03-19 20:52)
· 九城总裁陈晓薇5月期满离任 朱骏将代理总裁(2010-03-19 20:48)
· Google携手Intel和Sony推出"Google电视"(2010-03-19 20:44)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

1、使用属性代替可访问的数据成员

只要打算将数据暴露在类型的公有接口或受保护的接口中，我们都应该使用属性来实现。对于具有序列或者字典特征的类型，则应该采用索引器。所有数据成员都应一律声明为私有。使用属性的好处显而易见：我们可以得到更好的数据绑定支持，我们可以更容易地在将来对其访问方法的实现做任何改变。将变量封装在属性中只不过增加几行代码。如果刚开始使用数据成员，后来又发现需要使用属性，这时再来修改的成本将是几个小时。今天投入一点，会为明天节省许多时间。

JIT编译器会对某些方法调用（包括属性访问器）进行内联处理，属性和数据成员的效率没有任何差别。及时属性访问器没有被内联，实际的效率差别相对于函数调用的成本来讲也是可以忽略不计的。只有在很少的情况下，这种差别才值得我们注意。

2、运行时常量（readonly）优于编译时常量（const）

在c#中，我们用readonly关键字声明运行时常量，用const关键字来声明编译时常量。

编译时常量在编译后的结果代码中会被替换为该常量的值。运行时常量在运行时被计算，编译后代码将维持对readonly变量（而非它的值）的引用。

编译时常量只可用于值类型，运行时常量则没有限制。

使用const较之于使用readonly的唯一好处就是性能：使用已知常量值得代码效率要比访问readonly值的代码效率稍好一点，但是其中的效率提升是非常小的。

只有当某些情况要求变量的值必须在编译时可用，才应该考虑使用const，例如：特性（attribute）类的参数，枚举定义，以及某些不随组件版本变化而变化的值。否则，对于其他任何情况，都应该优先选择readonly常量，从而获得其所具有的灵活性。

3、操作符is或as优于强制转型

好的面向对象实践对告诫我们避免转型，但有时候我们别无选择。不能避免转型时，我们应该尽量使用as和is操作符来清晰的表达意图。

当我们要立即进行转型时，我们应使用as操作符。如果仅仅是进行类型的判断而不需要立即进行转型，使用is即可。

4、使用Conditional特性代替#if条件编译

使用Conditional特性比使用#if/#endif产生的IL代码更有效。同时，将其限制在函数层次上可以清晰的讲条件行代码分离出来，从而使我们的代码具有更好的机构。另外，C#编译器也为此提供了很好的支持，从而帮助我们避免以前使用#if或#endif时犯的错误。

5、总是提供ToString（）方法

System.Object默认提供的ToString（）方法会返回类型的名称。我们可以简单的重写ToString（）方法，来满足我们的要求。也可以提供重载的ToString（）方法，使用格式字符串来为我们的类型指定自己的格式，满足更复杂的需求。

6、优先采用foreach循环语句

foreach是一个非常有用的语句，它会使用最高效的构造为“数组的上下界索引”、“多维数组遍历”和“操作数转型”产生正确的代码，并且产生的是最具效率的循环结构。它是遍历集合的最佳方式。

任何集合类型都可以使用foreach。有3种方法可以使一个类支持foreach方法：

（1）类型具备一个公有的GetEnumerator()方法；

（2）类型显示实现了IEnumerable接口；

（3）类型实现了IEnumerator接口。

评论: 2　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· Notifo推iPhone应用：弥补邮件推送缺陷(2010-03-19 21:04)
· 分析：微软IE9现身 网络视频标准争议依旧未解(2010-03-19 20:57)
· 连线朱骏：陈晓薇离开九城与魔兽无关(2010-03-19 20:52)
· 九城总裁陈晓薇5月期满离任 朱骏将代理总裁(2010-03-19 20:48)
· Google携手Intel和Sony推出"Google电视"(2010-03-19 20:44)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

多态是面向对象的三个基本特性之一，因此在C#中正确理解和实现多态是非常重要的。

对于C#初学者而言，可能已经理解了多态的概念，但对于多态的实现，特别是关键字new，virtual，override的使用，仍然有种一头雾水的感觉。我查阅几本书，在网上看了一些相关的资料，总算是小有收获，在这里分享一下我的理解，希望对初学者有所帮助。

多态可以简单的理解为对不同的对象调用相同的方法，表现出不同的行为，这种特性是通过继承来实现的。先来看一个简单的例子，展现一下多态的实现。

例1：

public class Animal
    {
        public virtual void Eat()
        {
            Console.WriteLine("Animal eat");
        }
    }

    public class Cat : Animal
    {
        public override void Eat()
        {
            Console.WriteLine("Cat eat");
        }
    }

    public class Dog : Animal
    {
        public override void Eat()
        {
            Console.WriteLine("Dog eat");
        }
    }

    class Tester
    {
        static void Main(string[] args)
        {
            Animal[] animals = new Animal[3];

            animals[0] = new Animal();
            animals[1] = new Cat();
            animals[2] = new Dog();

            for (int i = 0; i < 3; i++)
            {
                animals[i].Eat();
            }
        }
    }

    输出如下：

Animal eat...

Cat eat...

Dog eat...

在上面的例子中，通过继承，使得Animal对象数组中的不同的对象，在调用Eat()方法时，表现出了不同的行为。

多态的实现看起来很简单，要完全理解及灵活的运用c#的多态机制，也不是一件容易的事，有很多需要注意的地方。

1. new的用法

先看下面的例子。

例2：

 public class Animal
    {
        public virtual void Eat()
        {
            Console.WriteLine("Animal eat");
        }
    }

    public class Cat : Animal
    {
        public new void Eat()
        {
            Console.WriteLine("Cat eat");
        }
    }

    class Tester
    {
        static void Main(string[] args)
        {
            Animal a = new Animal();
            a.Eat();

            Animal ac = new Cat();
            ac.Eat();

            Cat c = new Cat();
            c.Eat();
        }
    }

    运行结果为：

Animal eat...

Animal eat...

Cat eat...

可以看出，当派生类Cat的Eat()方法使用new修饰时，Cat的对象转换为Animal对象后，调用的是Animal类中的Eat()方法。其实可以理解为，使用new关键字后，使得Cat中的Eat()方法和Animal中的Eat()方法成为毫不相关的两个方法，只是它们的名字碰巧相同而已。所以， Animal类中的Eat()方法不管用还是不用virtual修饰，也不管访问权限如何，或者是没有，都不会对Cat的Eat()方法产生什么影响（只是因为使用了new关键字，如果Cat类没用从Animal类继承Eat()方法，编译器会输出警告）。

我想这是设计者有意这么设计的，因为有时候我们就是要达到这种效果。严格的说，不能说通过使用new来实现多态，只能说在某些特定的时候碰巧实现了多态的效果。

2.override实现多态

真正的多态使用override来实现的。回过去看前面的例1，在基类Animal中将方法Eat()用virtual标记为虚拟方法，再在派生类Cat和Dog中用override对Eat()修饰，进行重写，很简单就实现了多态。需要注意的是，要对一个类中一个方法用override修饰，该类必须从父类中继承了一个对应的用virtual修饰的虚拟方法，否则编译器将报错。

好像讲得差不多了，还有一个问题，不知道你想没有。就是多层继承中又是怎样实现多态的。比如类A是基类，有一个虚拟方法method()（virtual修饰），类B继承自类A，并对method()进行重写（override修饰），现在类C又继承自类B，是不是可以继续对method()进行重写，并实现多态呢？看下面的例子。

例3：

     运行结果为：

Animal eat...

Dog eat...

WolfDog eat... 

在上面的例子中类Dog继承自类Animal，对方法Eat()进行了重写，类WolfDog又继承自Dog，再一次对Eat()方法进行了重写，并很好地实现了多态。不管继承了多少层，都可以在子类中对父类中已经重写的方法继续进行重写，即如果父类方法用override修饰，如果子类继承了该方法，也可以用override修饰，多层继承中的多态就是这样实现的。要想终止这种重写，只需重写方法时用sealed关键字进行修饰即可。 

3. abstract-override实现多态

先在我们在来讨论一下用abstract修饰的抽象方法。抽象方法只是对方法进行了定义，而没有实现，如果一个类包含了抽象方法，那么该类也必须用abstract声明为抽象类，一个抽象类是不能被实例化的。对于类中的抽象方法，可以再其派生类中用override进行重写，如果不重写，其派生类也要被声明为抽象类。看下面的例子。

例4：

public abstract class Animal
    {
    }

    public class Cat : Animal
    {
        public override void Eat()
        {
            Console.WriteLine("Cat eat");
        }
    }

    public class Dog : Animal
    {
        public override void Eat()
        {
            Console.WriteLine("Dog eat");
        }
    }

    public class WolfDog : Dog
    {
        public override void Eat()
        {
            Console.WriteLine("Wolfdog eat");
        }
    }

    class Tester
    {
        static void Main(string[] args)
        {
            Animal[] animals = new Animal[3];

            animals[0] = new Cat();
            animals[1] = new Dog();
            animals[2] = new WolfDog();

            for (int i = 0; i < animals.Length; i++)
            {
                animals[i].Eat();
            }
        }
    }

     运行结果为：

Cat eat...

Dog eat...

Wolfdog eat...

从上面可以看出，通过使用abstract-override可以和virtual-override一样地实现多态，包括多层继承也是一样的。不同之处在于，包含虚拟方法的类可以被实例化，而包含抽象方法的类不能被实例化。

以上就是我对c#中多态的一些浅薄的认识，如有错误的地方，欢迎批评指正！

评论: 1　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· Notifo推iPhone应用：弥补邮件推送缺陷(2010-03-19 21:04)
· 分析：微软IE9现身 网络视频标准争议依旧未解(2010-03-19 20:57)
· 连线朱骏：陈晓薇离开九城与魔兽无关(2010-03-19 20:52)
· 九城总裁陈晓薇5月期满离任 朱骏将代理总裁(2010-03-19 20:48)
· Google携手Intel和Sony推出"Google电视"(2010-03-19 20:44)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

委托和事件在 .Net Framework中的应用非常广泛，然而，较好地理解委托和事件对很多接触C#时间不长的人来说并不容易。它们就像是一道槛儿，过了这个槛的人，觉得真是太容易了，而没有过去的人每次见到委托和事件就觉得心里别（biè）得慌，混身不自在。本文中，我将通过两个范例由浅入深地讲述什么是委托、为什么要使用委托、事件的由来、.Net Framework中的委托和事件、委托和事件对Observer设计模式的意义，对它们的中间代码也做了讨论。

将方法作为方法的参数
我们先不管这个标题如何的绕口，也不管委托究竟是个什么东西，来看下面这两个最简单的方法，它们不过是在屏幕上输出一句问候的话语：

以下为引用的内容：
       public void GreetPeople(string name) {
              // 做某些额外的事情，比如初始化之类，此处略
              EnglishGreeting(name);
       }
       public void EnglishGreeting(string name) {
              Console.WriteLine(”Morning, ” + name);
       }      
 

暂且不管这两个方法有没有什么实际意义。GreetPeople用于向某人问好，当我们传递代表某人姓名的name参数，比如说“Jimmy”，进去的时候，在这个方法中，将调用EnglishGreeting方法，再次传递name参数，EnglishGreeting则用于向屏幕输出 “Morning, Jimmy”。

现在假设这个程序需要进行全球化，哎呀，不好了，我是人，我不明白“Morning”是什么意思，怎么办呢？好吧，我们再加个中文版的问候方法：

以下为引用的内容：
public void ChineseGreeting(string name){
       Console.WriteLine(”早上好, ” + name);
}
 

这时候，GreetPeople也需要改一改了，不然如何判断到底用哪个版本的Greeting问候方法合适呢？在进行这个之前，我们最好再定义一个枚举作为判断的依据：
以下为引用的内容：
public enum Language{
       English, Chinese
}
public void GreetPeople(string name, Language lang){
       //做某些额外的事情，比如初始化之类，此处略
       swith(lang){
              case Language.English:
                     EnglishGreeting(name);
                     break;
              case Language.Chinese:
                     ChineseGreeting(name);
                     break;
              }
}
 
OK，尽管这样解决了问题，但我不说大家也很容易想到，这个解决方案的可扩展性很差，如果日后我们需要再添加韩文版、日文版，就不得不反复修改枚举和GreetPeople()方法，以适应新的需求。

在考虑新的解决方案之前，我们先看看 GreetPeople的方法签名：
public void GreetPeople(string name, Language lang)

我们仅看 string name，在这里，string 是参数类型，name 是参数变量，当我们赋给name字符串“jimmy”时，它就代表“jimmy”这个值；当我们赋给它“张子阳”时，它又代表着“张子阳”这个值。然后，我们可以在方法体内对这个name进行其他操作。哎，这简直是废话么，刚学程序就知道了。 Www~

如果你再仔细想想，假如GreetPeople()方法可以接受一个参数变量，这个变量可以代表另一个方法，当我们给这个变量赋值 EnglishGreeting的时候，它代表着 EnglsihGreeting() 这个方法；当我们给它赋值ChineseGreeting 的时候，它又代表着ChineseGreeting()方法。我们将这个参数变量命名为 MakeGreeting，那么不是可以如同给name赋值时一样，在调用 GreetPeople()方法的时候，给这个MakeGreeting 参数也赋上值么(ChineseGreeting或者EnglsihGreeting等)？然后，我们在方法体内，也可以像使用别的参数一样使用MakeGreeting。但是，由于MakeGreeting代表着一个方法，它的使用方式应该和它被赋的方法(比如ChineseGreeting)是一样的，比如：

MakeGreeting(name);

好了，有了思路了，我们现在就来改改GreetPeople()方法，那么它应该是这个样子了：
以下为引用的内容：
public void GreetPeople(string name, *** MakeGreeting){
       MakeGreeting(name);
}

注意到 *** ，这个位置通常放置的应该是参数的类型，但到目前为止，我们仅仅是想到应该有个可以代表方法的参数，并按这个思路去改写GreetPeople方法，现在就出现了一个大问题：这个代表着方法的MakeGreeting参数应该是什么类型的？

NOTE：这里已不再需要枚举了，因为在给MakeGreeting赋值的时候动态地决定使用哪个方法，是ChineseGreeting还是 EnglishGreeting，而在这个两个方法内部，已经对使用“morning”还是“早上好”作了区分。

聪明的你应该已经想到了，现在是委托该出场的时候了，但讲述委托之前，我们再看看MakeGreeting参数所能代表的 ChineseGreeting()和EnglishGreeting()方法的签名：
public void EnglishGreeting(string name)
public void ChineseGreeting(string name)

如同name可以接受String类型的“true”和“1”，但不能接受bool类型的true和int类型的1一样。MakeGreeting的 参数类型定义 应该能够确定 MakeGreeting可以代表的 方法种类，再进一步讲，就是MakeGreeting可以代表的方法 的 参数类型和祷乩嘈汀?br /> 于是，委托出现了：它定义了MakeGreeting参数所能代表的方法的种类，也就是MakeGreeting参数的类型。
NOTE：如果上面这句话比较绕口，我把它翻译成这样：string 定义了name参数所能代表的值的种类，也就是name参数的类型。

本例中委托的定义：

public delegate void GreetingDelegate(string name);
可以与上面EnglishGreeting()方法的签名对比一下，除了加入了delegate关键字以外，其余的是不是完全一样？

现在，让我们再次改动GreetPeople()方法，如下所示：

以下为引用的内容：
public void GreetPeople(string name, GreetingDelegate MakeGreeting){
       MakeGreeting(name);
}
 

如你所见，委托GreetingDelegate出现的位置与 string相同，string是一个类型，那么GreetingDelegate应该也是一个类型，或者叫类(Class)。但是委托的声明方式和类却完全不同，这是怎么一回事？实际上，委托在编译的时候确实会编译成类。因为Delegate是一个类，所以在任何可以声明类的地方都可以声明委托。更多的内容将在下面讲述，现在，请看看这个范例的完整代码：

.

以下为引用的内容：
using System;
using System.Collections.Generic;
using System.Text;
namespace Delegate {
       //定义委托，它定义了可以代表的方法的类型
       public delegate void GreetingDelegate(string name);

       class Program {
              private static void EnglishGreeting(string name) {
                     Console.WriteLine(”Morning, ” + name);
              } Www~

              private static void ChineseGreeting(string name) {
                     Console.WriteLine(”早上好, ” + name);
              }

              //注意此方法，它接受一个GreetingDelegate类型的方法作为参数
              private static void GreetPeople(string name, GreetingDelegate MakeGreeting) {
                     MakeGreeting(name);
              }

              static void Main(string[] args) {
                     GreetPeople(”Jimmy Zhang”, EnglishGreeting);
                     GreetPeople(”张子阳”, ChineseGreeting);
                     Console.ReadKey();
              }
       }
} Www~
 

输出如下：

Morning, Jimmy Zhang

早上好, 张子阳

我们现在对委托做一个总结：

委托是一个类，它定义了方法的类型，使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使得程序具有更好的可扩展性。

将方法绑定到委托 .

看到这里，是不是有那么点如梦初醒的感觉？于是，你是不是在想：在上面的例子中，我不一定要直接在GreetPeople()方法中给 name参数赋值，我可以像这样使用变量：

以下为引用的内容：
static void Main(string[] args) {
       string name1, name2;
       name1 = “Jimmy Zhang”;
       name2 = “张子阳”;

       GreetPeople(name1, EnglishGreeting);
       GreetPeople(name2, ChineseGreeting);
       Console.ReadKey();
}
 
而既然委托GreetingDelegate 和 类型 string 的地位一样，都是定义了一种参数类型，那么，我是不是也可以这么使用委托？
以下为引用的内容：
static void Main(string[] args) {
       GreetingDelegate delegate1, delegate2;
       delegate1 = EnglishGreeting;
       delegate2 = ChineseGreeting;
       GreetPeople(”Jimmy Zhang”, delegate1);
       GreetPeople(”张子阳”, delegate2);
       Console.ReadKey();
}
如你所料，这样是没有问题的，程序一如预料的那样输出。这里，我想说的是委托不同于string的一个特性：可以将多个方法赋给同一个委托，或者叫将多个方法绑定到同一个委托，当调用这个委托的时候，将依次调用其所绑定的方法。在这个例子中，语法如下：

以下为引用的内容：
static void Main(string[] args) {
       GreetingDelegate delegate1;
       delegate1 = EnglishGreeting;     // 先给委托类型的变量赋值
       delegate1 += ChineseGreeting;     // 给此委托变量再绑定一个方法

       // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
       GreetPeople(”Jimmy Zhang”, delegate1);     
       Console.ReadKey();
}

输出为：
Morning, Jimmy Zhang

早上好, Jimmy Zhang

实际上，我们可以也可以绕过GreetPeople方法，通过委托来直接调用EnglishGreeting和ChineseGreeting：

以下为引用的内容：
static void Main(string[] args) {
       GreetingDelegate delegate1;
       delegate1 = EnglishGreeting;     // 先给委托类型的变量赋值
       delegate1 += ChineseGreeting;     // 给此委托变量再绑定一个方法

       // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
       delegate1 (”Jimmy Zhang”);     
       Console.ReadKey();
}
 
NOTE：这在本例中是没有问题的，但回头看下上面GreetPeople()的定义，在它之中可以做一些对于EnglshihGreeting和ChineseGreeting来说都需要进行的工作，为了简便我做了省略。

Www~
注意这里，第一次用的“=”，是赋值的语法；第二次，用的是“+=”，是绑定的语法。如果第一次就使用“+=”，将出现“使用了未赋值的局部变量”的编译错误。
我们也可以使用下面的代码来这样简化这一过程：

GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);

delegate1 += ChineseGreeting;       // 给此委托变量再绑定一个方法 @com

看到这里，应该注意到，这段代码第一条语句与实例化一个类是何其的相似，你不禁想到：上面第一次绑定委托时不可以使用“+=”的编译错误，或许可以用这样的方法来避免：

GreetingDelegate delegate1 = new GreetingDelegate();

delegate1 += EnglishGreeting;       // 这次用的是 “+=”，绑定语法。

.

delegate1 += ChineseGreeting;       // 给此委托变量再绑定一个方法

但实际上，这样会出现编译错误： “GreetingDelegate”方法没有采用“0”个参数的重载。尽管这样的结果让我们觉得有点沮丧，但是编译的提示：“没有0个参数的重载”再次让我们联想到了类的构造函数。我知道你一定按捺不住想探个究竟，但再此之前，我们需要先把基础知识和应用介绍完。

既然给委托可以绑定一个方法，那么也应该有办法取消对方法的绑定，很容易想到，这个语法是“-=”：

以下为引用的内容：
static void Main(string[] args) {
       GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);
       delegate1 += ChineseGreeting;    // 给此委托变量再绑定一个方法
       // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
       GreetPeople(”Jimmy Zhang”, delegate1);     
       Console.WriteLine();

       delegate1 -= EnglishGreeting; //取消对EnglishGreeting方法的绑定
       // 将仅调用 ChineseGreeting
       GreetPeople(”张子阳”, delegate1);     
       Console.ReadKey();
}
 
输出为：

Morning, Jimmy Zhang

早上好, Jimmy Zhang Www_

早上好, 张子阳

让我们再次对委托作个总结：

使用委托可以将多个方法绑定到同一个委托变量，当调用此变量时(这里用“调用”这个词，是因为此变量代表一个方法)，可以依次调用所有绑定的方法。

事件的由来

我们继续思考上面的程序：上面的三个方法都定义在Programe类中，这样做是为了理解的方便，实际应用中，通常都是 GreetPeople 在一个类中，ChineseGreeting和 EnglishGreeting 在另外的类中。现在你已经对委托有了初步了解，是时候对上面的例子做个改进了。假设我们将GreetingPeople()放在一个叫GreetingManager的类中，那么新程序应该是这个样子的：

Www_

以下为引用的内容：
namespace Delegate {
       //定义委托，它定义了可以代表的方法的类型
       public delegate void GreetingDelegate(string name);
     
       //新建的GreetingManager类
       public class GreetingManager{
              public void GreetPeople(string name, GreetingDelegate MakeGreeting) {
                     MakeGreeting(name); .
              }
              }
       class Program {
              private static void EnglishGreeting(string name) {
                     Console.WriteLine(”Morning, ” + name);
              }

              private static void ChineseGreeting(string name) {
                     Console.WriteLine(”早上好, ” + name);
              } @com

              static void Main(string[] args) {
                     // … …
              }
       }
}

Www~
 
 

这个时候，如果要实现前面演示的输出效果，Main方法我想应该是这样的：

以下为引用的内容：
static void Main(string[] args) {
       GreetingManager gm = new  GreetingManager();
       gm.GreetPeople(”Jimmy Zhang”, EnglishGreeting);
       gm.GreetPeople(”张子阳”, ChineseGreeting);
}
 

我们运行这段代码，嗯，没有任何问题。程序一如预料地那样输出了：
Morning, Jimmy Zhang
早上好, 张子阳

现在，假设我们需要使用上一节学到的知识，将多个方法绑定到同一个委托变量，该如何做呢？让我们再次改写代码：

以下为引用的内容：

static void Main(string[] args) {
       GreetingManager gm = new  GreetingManager();
       GreetingDelegate delegate1;
       delegate1 = EnglishGreeting;
       delegate1 += ChineseGreeting;

       gm.GreetPeople(”Jimmy Zhang”, delegate1);
}
 
输出：

Www~
Morning, Jimmy Zhang

早上好, Jimmy Zhang
到了这里，我们不禁想到：面向对象设计，讲究的是对象的封装，既然可以声明委托类型的变量(在上例中是delegate1)，我们何不将这个变量封装到 GreetManager类中？在这个类的客户端中使用不是更方便么？于是，我们改写GreetManager类，像这样：

以下为引用的内容：
public class GreetingManager{
//在GreetingManager类的内部声明delegate1变量
       public GreetingDelegate delegate1;     
public void GreetPeople(string name, GreetingDelegate MakeGreeting) {
                     MakeGreeting(name);
       }
}
 
 

现在，我们可以这样使用这个委托变量：
以下为引用的内容：
static void Main(string[] args) {
       GreetingManager gm = new  GreetingManager();
       gm.delegate1 = EnglishGreeting;
       gm.delegate1 += ChineseGreeting;
       gm.GreetPeople(”Jimmy Zhang”, gm.delegate1);
}
 
尽管这样达到了我们要的效果，但是似乎并不美气，光是第一个方法注册用“=”，第二个用“+=”就让人觉得别扭。此时，轮到Event出场了，C# 中可以使用事件来专门完成这项工作，我们改写GreetingManager类，它变成了这个样子：
以下为引用的内容：
public class GreetingManager{
       //这一次我们在这里声明一个事件
       public event GreetingDelegate MakeGreet;
public void GreetPeople(string name, GreetingDelegate MakeGreeting) {
              MakeGreeting(name);
       }
}
 
.

很容易注意到：MakeGreet 事件的声明与之前委托变量delegate1的声明唯一的区别是多了一个event关键字。看到这里，你差不多明白到：事件其实没什么不好理解的，声明一个事件不过类似于声明一个委托类型的变量而已。

我们想当然地改写Main方法：
以下为引用的内容：
static void Main(string[] args) {
       GreetingManager gm = new  GreetingManager();
       gm.MakeGreet = EnglishGreeting; // 编译错误1
       gm.MakeGreet += ChineseGreeting;
       gm.GreetPeople(”Jimmy Zhang”, gm.MakeGreet); //编译错误2
}
 
这次，你会得到编译错误：事件“Delegate.GreetingManager.MakeGreet”只能出现在 += 或 -= 的左边(从类型“Delegate.GreetingManager”中使用时除外)。

事件和委托的编译代码

这时候，我们不得不注释掉编译错误的行，然后重新进行编译，再借助Reflactor来对 event的声明语句做一探究，看看为什么会发生这样的错误：
public event GreetingDelegate MakeGreet;
可以看到，实际上尽管我们在GreetingManager里将 MakeGreet 声明为public，但是，实际上MakeGreet会被编译成 私有字段，难怪会发生上面的编译错误了，因为它根本就不允许在GreetingManager类的外面以赋值的方式访问。
我们进一步看下MakeGreet所产生的代码：

以下为引用的内容：

private GreetingDelegate MakeGreet;       //对事件的声明 实际是 声明一个私有的委托变量

[MethodImpl(MethodImplOptions.Synchronized)]
public void add_MakeGreet(GreetingDelegate value){
    this.MakeGreet = (GreetingDelegate) Delegate.Combine(this.MakeGreet, value);
}

[MethodImpl(MethodImplOptions.Synchronized)]
public void remove_MakeGreet(GreetingDelegate value){
    this.MakeGreet = (GreetingDelegate) Delegate.Remove(this.MakeGreet, value);
}
 
 

现在已经很明确了：MakeGreet 事件确实是一个GreetingDelegate类型的委托，只不过不管是不是声明为public，它总是被声明为private。另外，它还有两个方法，分别是add_MakeGreet和remove_MakeGreet，这两个方法分别用于注册委托类型的方法和取消注册，实际上也就是： “+= ”对应 add_MakeGreet，“-=”对应remove_MakeGreet。而这两个方法的访问限制取决于声明事件时的访问限制符。

在add_MakeGreet()方法内部，实际上调用了System.Delegate的Combine()静态方法，这个方法用于将当前的变量添加到委托链表中。我们前面提到过两次，说委托实际上是一个类，在我们定义委托的时候：
public delegate void GreetingDelegate(string name);

当编译器遇到这段代码的时候，会生成下面这样一个完整的类：

以下为引用的内容：

public class GreetingDelegate:System.MulticastDelegate{

       public GreetingDelegate(object @object, IntPtr method);
       public virtual IAsyncResult BeginInvoke(string name, AsyncCallback callback, object @object);
       public virtual void EndInvoke(IAsyncResult result);
       public virtual void Invoke(string name);
}
 
 

关于这个类的更深入内容，可以参阅《CLR Via C#》等相关书籍，这里就不再讨论了。

委托、事件与Observer设计模式
范例说明
上面的例子已不足以再进行下面的讲解了，我们来看一个新的范例，因为之前已经介绍了很多的内容，所以本节的进度会稍微快一些：
假设我们有个高档的热水器，我们给它通上电，当水温超过95度的时候：1、扬声器会开始发出语音，告诉你水的温度；2、液晶屏也会改变水温的显示，来提示水已经快烧开了。

现在我们需要写个程序来模拟这个烧水的过程，我们将定义一个类来代表热水器，我们管它叫：Heater，它有代表水温的字段，叫做temperature；当然，还有必不可少的给水加热方法BoilWater()，一个发出语音警报的方法MakeAlert()，一个显示水温的方法，ShowMsg()。
以下为引用的内容：
namespace Delegate {
       class Heater {
              private int temperature; // 水温
              // 烧水
              public void BoilWater() {
                     for (int i = 0; i <= 100; i++) {
                            temperature = i;

                            if (temperature > 95) {
                                   MakeAlert(temperature);
                                   ShowMsg(temperature);
                            }
                     }
              }
              // 发出语音警报
              private void MakeAlert(int param) {
                     Console.WriteLine(”Alarm：嘀嘀嘀，水已经 {0} 度了：” , param);
              }
            
              // 显示水温
              private void ShowMsg(int param) {
                     Console.WriteLine(”Display：水快开了，当前温度：{0}度。” , param);
              }

.

       }

       class Program {
              static void Main() {
                     Heater ht = new Heater();
                     ht.BoilWater();
              }
       }
}
 

Observer设计模式简介

上面的例子显然能完成我们之前描述的工作，但是却并不够好。现在假设热水器由三部分组成：热水器、警报器、显示器，它们来自于不同厂商并进行了组装。那么，应该是热水器仅仅负责烧水，它不能发出警报也不能显示水温；在水烧开时由警报器发出警报、显示器显示提示和水温。

这时候，上面的例子就应该变成这个样子：

以下为引用的内容：

// 热水器
public class Heater {     
              private int temperature;
                   
              // 烧水
              private void BoilWater() {
                     for (int i = 0; i <= 100; i++) {
                            temperature = i;
                     }
              }
       }

       // 警报器
       public class Alarm{
              private void MakeAlert(int param) {
                     Console.WriteLine(”Alarm：嘀嘀嘀，水已经 {0} 度了：” , param);
              }
       }

       // 显示器
       public class Display{
              private void ShowMsg(int param) {
                     Console.WriteLine(”Display：水已烧开，当前温度：{0}度。” , param);
              }
}
 
这里就出现了一个问题：如何在水烧开的时候通知报警器和显示器？在继续进行之前，我们先了解一下Observer设计模式，Observer设计模式中主要包括如下两类对象：
Subject：监视对象，它往往包含着其他对象所感兴趣的内容。在本范例中，热水器就是一个监视对象，它包含的其他对象所感兴趣的内容，就是temprature字段，当这个字段的值快到100时，会不断把数据发给监视它的对象。

Observer：监视者，它监视Subject，当Subject中的某件事发生的时候，会告知Observer，而Observer则会采取相应的行动。在本范例中，Observer有警报器和显示器，它们采取的行动分别是发出警报和显示水温。
在本例中，事情发生的顺序应该是这样的：

警报器和显示器告诉热水器，它对它的温度比较感兴趣(注册)。

热水器知道后保留对警报器和显示器的引用。

热水器进行烧水这一动作，当水温超过95度时，通过对警报器和显示器的引用，自动调用警报器的MakeAlert()方法、显示器的ShowMsg()方法。
类似这样的例子是很多的，GOF对它进行了抽象，称为Observer设计模式：Observer设计模式是为了定义对象间的一种一对多的依赖关系，以便于当一个对象的状态改变时，其他依赖于它的对象会被自动告知并更新。Observer模式是一种松耦合的设计模式。 Www~

实现范例的Observer设计模式

我们之前已经对委托和事件介绍很多了，现在写代码应该很容易了，现在在这里直接给出代码，并在注释中加以说明。
以下为引用的内容：
using System;
using System.Collections.Generic;
using System.Text;
namespace Delegate {
       // 热水器
       public class Heater {
              private int temperature;
              public delegate void BoilHandler(int param);       //声明委托
              public event BoilHandler BoilEvent;                     //声明事件

              // 烧水
              public void BoilWater() {
                     for (int i = 0; i <= 100; i++) {
                            temperature = i;

Www~
                            if (temperature > 95) {
                                   if (BoilEvent != null) {       //如果有对象注册
                                          BoilEvent(temperature);       //调用所有注册对象的方法
                                   }
                            }
                     }
              }
       }
       // 警报器
       public class Alarm {
              public void MakeAlert(int param) {
                     Console.WriteLine(”Alarm：嘀嘀嘀，水已经 {0} 度了：”, param);
              }
       }

       // 显示器
       public class Display {
              public static void ShowMsg(int param) {       //静态方法
                     Console.WriteLine(”Display：水快烧开了，当前温度：{0}度。”, param);
              }
       }
     
       class Program {
              static void Main() {
                     Heater heater = new Heater();
                     Alarm alarm = new Alarm();

.

                     heater.BoilEvent += alarm.MakeAlert;       //注册方法
                     heater.BoilEvent += (new Alarm()).MakeAlert;       //给匿名对象注册方法
                     heater.BoilEvent += Display.ShowMsg;              //注册静态方法 .

                     heater.BoilWater();       //烧水，会自动调用注册过对象的方法
              }
       }
}

输出为：

Alarm：嘀嘀嘀，水已经 96 度了： Www_

Alarm：嘀嘀嘀，水已经 96 度了：

Display：水快烧开了，当前温度：96度。
// 省略… @com

.Net Framework中的委托与事件

尽管上面的范例很好地完成了我们想要完成的工作，但是我们不仅疑惑：为什么.Net Framework 中的事件模型和上面的不同？为什么有很多的EventArgs参数？

在回答上面的问题之前，我们先搞懂 .Net Framework的编码规范：

委托类型的名称都应该以EventHandler结束。
委托的原型定义：有一个void返回值，并接受两个输入参数：一个Object 类型，一个 EventArgs类型(或继承自EventArgs)。

事件的命名为 委托去掉 EventHandler之后剩余的部分。

继承自EventArgs的类型应该以EventArgs结尾。
再做一下说明：
委托声明原型中的Object类型的参数代表了Subject，也就是监视对象，在本例中是 Heater(热水器)。回调函数(比如Alarm的MakeAlert)可以通过它访问触发事件的对象(Heater)。

EventArgs 对象包含了Observer所感兴趣的数据，在本例中是temperature。
上面这些其实不仅仅是为了编码规范而已，这样也使得程序有更大的灵活性。比如说，如果我们不光想获得热水器的温度，还想在Observer端(警报器或者显示器)方法中获得它的生产日期、型号、价格，那么委托和方法的声明都会变得很麻烦，而如果我们将热水器的引用传给警报器的方法，就可以在方法中直接访问热水器了。

现在我们改写之前的范例，让它符合 .Net Framework 的规范：

以下为引用的内容：

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

namespace Delegate {
       // 热水器
       public class Heater {
              private int temperature;
              public string type = “RealFire 001″;              // 添加型号作为演示
              public string area = “China Xian”;                     // 添加产地作为演示
              //声明委托
              public delegate void BoiledEventHandler(Object sender, BoliedEventArgs e);
              public event BoiledEventHandler Boiled;       //声明事件

              // 定义BoliedEventArgs类，传递给Observer所感兴趣的信息
              public class BoliedEventArgs : EventArgs {
                     public readonly int temperature;
                     public BoliedEventArgs(int temperature) {
                            this.temperature = temperature;
                     }
              }

              // 可以供继承自 Heater 的类重写，以便继承类拒绝其他对象对它的监视
              protected virtual void OnBolied(BoliedEventArgs e) {
                     if (Boiled != null) {       // 如果有对象注册
                            Boiled(this, e);       // 调用所有注册对象的方法
                     }
              }
             
              // 烧水。
              public void BoilWater() {
                     for (int i = 0; i <= 100; i++) {
                            temperature = i;
                            if (temperature > 95) {
                                   //建立BoliedEventArgs 对象。
                                   BoliedEventArgs e = new BoliedEventArgs(temperature); .
                                   OnBolied(e);       // 调用 OnBolied方法
                            }
                     }
              }
       }

       // 警报器
       public class Alarm {
              public void MakeAlert(Object sender, Heater.BoliedEventArgs e) {
                     Heater heater = (Heater)sender;              //这里是不是很熟悉呢？
                     //访问 sender 中的公共字段
                     Console.WriteLine(”Alarm：{0} - {1}: “, heater.area, heater.type);
                     Console.WriteLine(”Alarm: 嘀嘀嘀，水已经 {0} 度了：”, e.temperature);
                     Console.WriteLine();
              }

       }
       // 显示器
       public class Display {
              public static void ShowMsg(Object sender, Heater.BoliedEventArgs e) {       //静态方法
                     Heater heater = (Heater)sender;
                     Console.WriteLine(”Display：{0} - {1}: “, heater.area, heater.type);
                     Console.WriteLine(”Display：水快烧开了，当前温度：{0}度。”, e.temperature);
                     Console.WriteLine();
              }
       }

       class Program {
              static void Main() {
                     Heater heater = new Heater();
                     Alarm alarm = new Alarm();

                     heater.Boiled += alarm.MakeAlert;       //注册方法
                     heater.Boiled += (new Alarm()).MakeAlert;              //给匿名对象注册方法
                     heater.Boiled += new Heater.BoiledEventHandler(alarm.MakeAlert);       //也可以这么注册
                     heater.Boiled += Display.ShowMsg;              //注册静态方法

                     heater.BoilWater();       //烧水，会自动调用注册过对象的方法
              }
       }
}

Www_
 

输出为：

以下为引用的内容：
Alarm：China Xian - RealFire 001:
Alarm: 嘀嘀嘀，水已经 96 度了：
Alarm：China Xian - RealFire 001:
Alarm: 嘀嘀嘀，水已经 96 度了：
Alarm：China Xian - RealFire 001:
Alarm: 嘀嘀嘀，水已经 96 度了：
Display：China Xian - RealFire 001:
Display：水快烧开了，当前温度：96度。
// 省略 …
总结

在本文中我首先通过一个GreetingPeople的小程序向大家介绍了委托的概念、委托用来做什么，随后又引出了事件，接着对委托与事件所产生的中间代码做了粗略的讲述。

在第二个稍微复杂点的热水器的范例中，我向大家简要介绍了 Observer设计模式，并通过实现这个范例完成了该模式，随后讲述了.Net Framework中委托、事件的实现方式。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/fdsa123456/archive/2009/02/11/3877678.aspx

评论: 1　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· Notifo推iPhone应用：弥补邮件推送缺陷(2010-03-19 21:04)
· 分析：微软IE9现身 网络视频标准争议依旧未解(2010-03-19 20:57)
· 连线朱骏：陈晓薇离开九城与魔兽无关(2010-03-19 20:52)
· 九城总裁陈晓薇5月期满离任 朱骏将代理总裁(2010-03-19 20:48)
· Google携手Intel和Sony推出"Google电视"(2010-03-19 20:44)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

原文

转自http://www.cnblogs.com/sifang2004/archive/2006/01/12/316313.html

Attributes in C#

介绍

Attributes是一种新的描述信息，我们既可以使用attributes来定义设计期信息（例如 帮助文件，文档的URL），还可以用attributes定义运行时信息（例如，使XML中的元素与类的成员字段关联起来）。我们也可以用attributes来创建一个“自描述”的组件。在这篇指南中我们将明白怎么创建属性并将其绑定至各种语言元素上，另外我们怎样在运行时环境下获取到attributes的一些信息。

定义

MSDN 中做如下定义(ms-help://MS.MSDNQTR.2002APR.1033/csspec/html/vclrfcsharpspec_17_2.htm)

"An attribute is a piece of additional declarative information that is specified for a declaration." 

使用预定义 Attributes

在c#中已有一小组预定义的attributes，在我们学习怎样创建自定义attributes前，先来了解下在我们的代码中使用那些预定义的attributes.

仔细看下该实例，在该实例中我们用到了”Obsolete”attribute，它标记了一个不该再被使用的语言元素（译者注：这里的元素为方法），该属性的第一个参数是string类型，它解释为什么该元素被荒弃，以及我们该使用什么元素来代替它。实际中，我们可以书写任何其它文本来代替这段文本。第二个参数是告诉编译器把依然使用这被标识的元素视为一种错误，这就意味着编译器会因此而产生一个警告。

当我们试图编译上面的上面的程序，我们会得到如下错误：

AnyClass.Old()' is obsolete: 'Don't use Old method,  use New method'

开发自定义Attributes

现在我们即将了解怎么开发自定义的attributes。这儿有个小小处方，有它我们就可以学会创建自定义的attributes。

在C#中，我们的attribute类都派生于System.Attribute类 (A class that derives from the abstract class System.Attribute, whether directly or indirectly, is an attribute class. The declaration of an attribute class defines a new kind of attribute that can be placed on a declaration) ，我们就这么行动吧。

评论: 0　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· Notifo推iPhone应用：弥补邮件推送缺陷(2010-03-19 21:04)
· 分析：微软IE9现身 网络视频标准争议依旧未解(2010-03-19 20:57)
· 连线朱骏：陈晓薇离开九城与魔兽无关(2010-03-19 20:52)
· 九城总裁陈晓薇5月期满离任 朱骏将代理总裁(2010-03-19 20:48)
· Google携手Intel和Sony推出"Google电视"(2010-03-19 20:44)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库

在Windows Mobile 中，窗体类Form的属性WindowState可以设置窗体的状态，但枚举类型FormWindowState只有Maximized（最大化）和Normal（正常），而没有最小化。以下的代码可以实现窗体最小化的功能，从面对窗口进行隐藏。

评论: 0　查看评论　发表评论

找优秀程序员，就在博客园

最新新闻：
· Notifo推iPhone应用：弥补邮件推送缺陷(2010-03-19 21:04)
· 分析：微软IE9现身 网络视频标准争议依旧未解(2010-03-19 20:57)
· 连线朱骏：陈晓薇离开九城与魔兽无关(2010-03-19 20:52)
· 九城总裁陈晓薇5月期满离任 朱骏将代理总裁(2010-03-19 20:48)
· Google携手Intel和Sony推出"Google电视"(2010-03-19 20:44)

编辑推荐：[视频]想做你的Code

网站导航：博客园首页  个人主页  新闻  闪存  小组  博问  社区  知识库