引言： 
　C# 3中所有特性的提出都是更好地为Linq服务的， 充分理解这些基础特性后。对于更深层次地去理解Linq的架构方面会更加简单，从而就可以自己去实现一个简单的ORM框架的，对于Linq的学习在下一个专题中将会简单和大家介绍下，这个专题还是先来介绍服务于Linq的基础特性——扩展方法
一、扩展方法的介绍
　我一般理解一个知识点喜欢拆分去理解,所以对于扩展方法的理解可以拆分为——首先它肯定是一个方法，然而方法又是对于一个类型而言的，所以扩展方法可以理解为 现有的类型(现有类型可以为自定义的类型和.Net 类库中的类型)扩展(添加)应该附加到该类型中的方法。
　　在没有扩展方法之前,如果我们想为一个已有类型自定义自己逻辑的方法时,我们 必须自定义一个新的类型来继承已有类型的方式来添加方法,使用这种继承方式来添加方法时,我们必须自定义一个新的派生类型,如果基类有抽象方法还需要重新去实现抽象方法,这样为了扩展一个方法却会导致因继承而带来的其他的开销(指的是又要去自定义一个派生类，还要覆盖基类的抽象方法等)，所以使用继承来为现有类型扩展方法时就有点大才小用的感觉了，并且当我们需要为值类型和密封类（不能被继承的类）这些不能被继承的类型扩展方法时，此时继承就不能被我们所用了， 所以在C#3 中提出了用扩展方法来实现为现有类型添加方法。使用扩展方法来实现扩展可以解决使用继承中所带来的所有的弊端,下面通过一个例子来演示下扩展方法的使用： 

   
   
    

    
    
  1. class Program 
    2. 

    
    
  2.     { 
    3. 

    
    
  3.         /// <summary> 
    4. 

    
    
  4.         ///  扩展方法演示 
    5. 

    
    
  5.         /// </summary> 
    6. 

    
    
  6.         /// <param name="args"></param> 
    7. 

    
    
  7.         static void Main(string[] args) 
    8. 

    
    
  8.         { 
    9. 

    
    
  9.             #region 演示扩展方法的使用 
    10. 

    
    
  10.  
    11. 

    
    
  11.             // 调用扩展方法 
    12. 

    
    
  12.             WebRequest request = WebRequest.Create("http://www.cnblogs.com"); 
    13. 

    
    
  13.             using (WebResponse response = request.GetResponse()) 
    14. 

    
    
  14.             { 
    15. 

    
    
  15.                 using(Stream responsestream =response.GetResponseStream()) 
    16. 

    
    
  16.                 { 
    17. 

    
    
  17.                     using (FileStream output = File.Create("response.htm")) 
    18. 

    
    
  18.                     { 
    19. 

    
    
  19.                         // 调用扩展方法 
    20. 

    
    
  20.                         responsestream.CopyToNewStream(output); 
    21. 

    
    
  21.                         Console.Read(); 
    22. 

    
    
  22.                     } 
    23. 

    
    
  23.                 } 
    24. 

    
    
  24.             } 
    25. 

    
    
  25.             #endregion  
    26. 

    
    
  26.  
    27. 

    
    
  27.           } 
    28. 

    
    
  28.     } 
    29. 

    
    
  29.  
    30. 

    
    
  30.     /// <summary> 
    31. 

    
    
  31.     /// 扩展方法必须在非泛型静态类中定义 
    32. 

    
    
  32.     /// </summary> 
    33. 

    
    
  33.     public static class StreamExten 
    34. 

    
    
  34.     { 
    35. 

    
    
  35.         // 定义扩展方法 
    36. 

    
    
  36.         // 该扩展方法实现从一个流中内容复制到另一个流中 
    37. 

    
    
  37.         public static void CopyToNewStream(this Stream inputstream, Stream outputstream) 
    38. 

    
    
  38.         { 
    39. 

    
    
  39.             byte[] buffer = new byte[8192]; 
    40. 

    
    
  40.             int read; 
    41. 

    
    
  41.             while ((read = inputstream.Read(buffer, 0, buffer.Length)) > 0) 
    42. 

    
    
  42.             { 
    43. 

    
    
  43.                 outputstream.Write(buffer, 0, read); 
    44. 

    
    
  44.             } 
    45. 

    
    
  45.         } 
    46. 

    
    
  46.     } 
    47.
  上面程序中为Stream类型扩展了一个CopyToNewStream()的方法，然而从上面扩展方法的定义中大家可以知道扩展方法定义的一些规则，然而并不是所有方法都可以作为扩展方法来使用的, 此时朋友们就会问,我如何去分辨代码中定义的是扩展方法还是普通的方法呢? 对于这个疑问,扩展方法的定义是要符合一些规则的,当看到定义的方法是符合这个规则,则就可以确定定义方法是扩展方法还是普通方法了。扩展方法必须具备下面的规则：
  • 它必须在一个非嵌套、非泛型的静态类中
  • 它至少要有一个参数
  • 第一个参数必须加上this关键字作为前缀（第一个参数类型也称为扩展类型，即指方法对这个类型进行扩展）
  • 第一个参数不能用其他任何修饰符（如不能使用ref out等修饰符）
  • 第一个参数的类型不能是指针类型
　　对于上面的规则大家可以在代码中试验下就会很容易明白,这些规则是一些硬性的规定,如果违反了这些规则,编译器可能会报错或者说编译器将不会认为定义的方法为扩展方法,下面简单演示下扩展方法必须在非嵌套类型的静态类中这个规则（其他规则同样大家可以在代码中进行测试），当我们把上面代码中 StreamExten 类定义为 Program嵌套类型时,编译器此时就会出现" 扩展方法必须在顶级静态类中定义;STreamExten是嵌套类"的编译时错误，演示代码如下： 

   
   
    

    
    
  1. View Code  
    2. 

    
    
  2.  
    3. 

    
    
  3. class Program 
    4. 

    
    
  4.     { 
    5. 

    
    
  5.         /// <summary> 
    6. 

    
    
  6.         /// 扩展方法必须在非泛型静态类中定义 
    7. 

    
    
  7.         /// </summary> 
    8. 

    
    
  8.         public static class StreamExten 
    9. 

    
    
  9.         { 
    10. 

    
    
  10.             // 定义扩展方法 
    11. 

    
    
  11.             // 该扩展方法实现从一个流中内容复制到另一个流中 
    12. 

    
    
  12.             public static void CopyToNewStream(this Stream inputstream, Stream outputstream) 
    13. 

    
    
  13.             { 
    14. 

    
    
  14.                 byte[] buffer = new byte[8192]; 
    15. 

    
    
  15.                 int read; 
    16. 

    
    
  16.                 while ((read = inputstream.Read(buffer, 0, buffer.Length)) > 0) 
    17. 

    
    
  17.                 { 
    18. 

    
    
  18.                     outputstream.Write(buffer, 0, read); 
    19. 

    
    
  19.                 } 
    20. 

    
    
  20.             } 
    21. 

    
    
  21.         } 
    22. 

    
    
  22.         /// <summary> 
    23. 

    
    
  23.         ///  扩展方法演示 
    24. 

    
    
  24.         /// </summary> 
    25. 

    
    
  25.         /// <param name="args"></param> 
    26. 

    
    
  26.         static void Main(string[] args) 
    27. 

    
    
  27.         { 
    28. 

    
    
  28.             #region 演示扩展方法的使用 
    29. 

    
    
  29.  
    30. 

    
    
  30.             // 调用扩展方法 
    31. 

    
    
  31.             WebRequest request = WebRequest.Create("http://www.cnblogs.com"); 
    32. 

    
    
  32.             using (WebResponse response = request.GetResponse()) 
    33. 

    
    
  33.             { 
    34. 

    
    
  34.                 using(Stream responsestream =response.GetResponseStream()) 
    35. 

    
    
  35.                 { 
    36. 

    
    
  36.                     using (FileStream output = File.Create("response.htm")) 
    37. 

    
    
  37.                     { 
    38. 

    
    
  38.                         // 调用扩展方法 
    39. 

    
    
  39.                         responsestream.CopyToNewStream(output); 
    40. 

    
    
  40.                         Console.Read(); 
    41. 

    
    
  41.                     } 
    42. 

    
    
  42.                 } 
    43. 

    
    
  43.             } 
    44. 

    
    
  44.             #endregion           
    45. 

    
    
  45.         } 
    46. 

    
    
  46.     } 
    47.
下面是出现编译时错误截图：
二、扩展方法是如何被发现的？
　　从上面部分的介绍,朋友们应该知道了如何定义和使用一个扩展方法，并且从我们定义的规则中可以帮助我们开发人员更好地去识别扩展方法，知道程序中调用的是一个实例方法还是一个扩展方法，然而相信大家此时会有这样一个疑问——编译器是如何知道我调用的是一个扩展方法而不是一个该类中的一个实例方法呢？对于这个问题，将在这部分和大家分析下。
　　首先讨论下程序员是如何去识别调用的是一个扩展方法而不是一个实例方法的,当我们看到调用方法的代码时,首先我们会去找该方法是否是该类(如上面程序中的Stream类)的一个实例方法，进入 Stream类(按F12进去查看)的定义中却发现该类中没有一个名为 CopyToNewStream的方法，此时我们就会查看程序中是否定义了这样的扩展方法，当找到一个为名CopyToNewStream这样的方法时，然后再根据定义的规则来判断找到的方法是否是为Stream类扩展的方法，这样的一个过程就是我们程序员去发现一个扩展方法的过程，然而对于编译器而言，它也是这么去发现扩展方法的（从而可以看出C#编译器还是非常智能的，完全按照人的思路去思考问题，因为它也是人实现出来的，就当然是尽可能地去以人的思考方式去实现的了），下面就介绍下编译器是如何去发现扩展方法的，这样也可以与程序员们的思路进行对比下。
　　当编译器看到变量调用的是一个方法时，它首先会去该对象中实例方法中去查看，一旦没有找到与调用方法同名的实例方法时，编译器就会去查找一个合适的扩展方法，它会检查导入的所有命名空间和当前的命名空间中的所有扩展方法，并匹配变量类型到扩展类型存在一个隐式转换的扩展方法。然而对于这个发现过程，可能有些人会问：编译器如何知道某个方法是扩展方法而不是实例方法呢？ 编译器是根据System.Runtime.CompilerServices.ExtensionAttribute属性来绑定方法是是否为扩展方法的， 当我们定义的方法是扩展方法时，该属性会自动应用到方法上,编译器还会将该特性应用到包含扩展方法的程序集上,对于这个两点并不是我的推断,下面给出反编译截图来证明下:
　从上面编译器发现扩展方法的过程可以得到方法调用的优先级的结论:现有的实例方法——>当前命名空间下的扩展方法——>导入命名空间的扩展方法。下面通过一个例子来演示编译器的发现过程： 

   
   
    

    
    
  1. using System; 
    2. 

    
    
  2.  
    3. 

    
    
  3. namespace 扩展方法如何被发现Demo 
    4. 

    
    
  4. { 
    5. 

    
    
  5.     // 要使用不同命名空间的扩展方法首先要添加该命名空间的引用 
    6. 

    
    
  6.     using CustomNamesapce; 
    7. 

    
    
  7.     class Program 
    8. 

    
    
  8.     { 
    9. 

    
    
  9.         static void Main(string[] args) 
    10. 

    
    
  10.         { 
    11. 

    
    
  11.             Person p = new Person { Name = "Learning hard" }; 
    12. 

    
    
  12.             // 当类型中包含了实例方法时，VS中的智能提示就只会列出实例方法，而不会列出扩展方法 
    13. 

    
    
  13.             // 当把实例方法注释掉之后，VS的智能提示中才会列出扩展方法，此时编译器在Person类型中找不到实例方法 
    14. 

    
    
  14.             // 所以首先从当前命名空间下查找是否有该名字的扩展方法，如果找到不会去其他命名空间中查找了 
    15. 

    
    
  15.             // 如果在当前命名空间中没有找到，则会到导入的命名空间中再进行查找 
    16. 

    
    
  16.             p.Print(); 
    17. 

    
    
  17.             p.Print("Hello"); 
    18. 

    
    
  18.             Console.Read(); 
    19. 

    
    
  19.         }   
    20. 

    
    
  20.     } 
    21. 

    
    
  21.  
    22. 

    
    
  22.     // 自定义类型 
    23. 

    
    
  23.     public class Person 
    24. 

    
    
  24.     { 
    25. 

    
    
  25.         public string Name { get; set; } 
    26. 

    
    
  26.  
    27. 

    
    
  27.          // 当类型中的实例方法 
    28. 

    
    
  28.         ////public void Print() 
    29. 

    
    
  29.         ////{ 
    30. 

    
    
  30.         ////    Console.WriteLine("调用实例方法输出，姓名为: {0}", Name); 
    31. 

    
    
  31.         ////} 
    32. 

    
    
  32.     } 
    33. 

    
    
  33.  
    34. 

    
    
  34.     // 当前命名空间下的扩展方法定义 
    35. 

    
    
  35.     public static class Extensionclass 
    36. 

    
    
  36.     { 
    37. 

    
    
  37.         /// <summary> 
    38. 

    
    
  38.         ///  扩展方法定义 
    39. 

    
    
  39.         /// </summary> 
    40. 

    
    
  40.         /// <param name="per"></param> 
    41. 

    
    
  41.         public static void Print(this Person per) 
    42. 

    
    
  42.         { 
    43. 

    
    
  43.             Console.WriteLine("调用的是同一命名空间下的扩展方法输出，姓名为: {0}", per.Name); 
    44. 

    
    
  44.         } 
    45. 

    
    
  45.     } 
    46. 

    
    
  46. } 
    47. 

    
    
  47.  
    48. 

    
    
  48. namespace CustomNamesapce 
    49. 

    
    
  49. { 
    50. 

    
    
  50.     using 扩展方法如何被发现Demo; 
    51. 

    
    
  51.  
    52. 

    
    
  52.     public static class CustomExtensionClass 
    53. 

    
    
  53.     { 
    54. 

    
    
  54.         /// <summary> 
    55. 

    
    
  55.         ///  扩展方法定义 
    56. 

    
    
  56.         /// </summary> 
    57. 

    
    
  57.         /// <param name="per"></param> 
    58. 

    
    
  58.         public static void Print(this Person per) 
    59. 

    
    
  59.         { 
    60. 

    
    
  60.             Console.WriteLine("调用的是不同命名空间下扩展方法输出，姓名为: {0}", per.Name); 
    61. 

    
    
  61.         } 
    62. 

    
    
  62.  
    63. 

    
    
  63.         /// <summary> 
    64. 

    
    
  64.         ///  扩展方法定义 
    65. 

    
    
  65.         /// </summary> 
    66. 

    
    
  66.         /// <param name="per"></param> 
    67. 

    
    
  67.         public static void Print(this Person per,string s) 
    68. 

    
    
  68.         { 
    69. 

    
    
  69.             Console.WriteLine("调用的是不同命名空间下扩展方法输出，姓名为: {0}, 附加字符串为{1}", per.Name, s); 
    70. 

    
    
  70.         } 
    71. 

    
    
  71.  
    72. 

    
    
  72.     } 
    73. 

    
    
  73. } 
    74.
运行结果:
　　当没有注释掉Person类中的实例方法Print时,此时在p后面键入.运算符时，智能提示将不会出现扩展方法（扩展方法前面有一个向下的箭头标示出来的），下面是没有注释实例方法时智能提示的截图(此时智能提示不会反射扩展方法出来)：
　　并且从上面运行结果可以看出,当调用p.Print()方法时，此时调用的是离该调用较近的命名空间下的Print方法(尽管在CustomNamesapce命名空间下也定义了扩展方法Print)。、然而 使用扩展方法还是存在一些问题的，如果同一个命名空间下的两个类都含有扩展类型相同的方法时，此时编译器就没有办法知道调用哪个方法了(这里标示出来引起大家的注意)。
三、在空引用上调用方法
 大家都知道在C#中，在空引用上调用实例方法是会引发NullReferenceException异常的，但是可以在空引用上调用扩展方法，下面看一段演示代码： 

   
   
    

    
    
  1. using System; 
    2. 

    
    
  2.  
    3. 

    
    
  3. namespace 在空引用上调用方法Demo 
    4. 

    
    
  4. { 
    5. 

    
    
  5.     // 必须引入扩展方法定义的命名空间 
    6. 

    
    
  6.     using ExtensionDefine; 
    7. 

    
    
  7.  
    8. 

    
    
  8.     class Program 
    9. 

    
    
  9.     { 
    10. 

    
    
  10.         static void Main(string[] args) 
    11. 

    
    
  11.         { 
    12. 

    
    
  12.             Console.WriteLine("空引用上调用扩展方法演示："); 
    13. 

    
    
  13.             string s = null; 
    14. 

    
    
  14.  
    15. 

    
    
  15.             // 在该程序中要使用扩展方法必须通过using来引用 
    16. 

    
    
  16.             // 在空引用上调用扩展方法不会发生NullReferenceException异常 
    17. 

    
    
  17.             // 之所以不会出现异常，是因为在空引用上调用扩展方法，对于编译器而言只是把空引用s当成参数传入静态方法中而已 
    18. 

    
    
  18.             // 对于编译器来说，s.IsNull()的调用等效于下面的代码 
    19. 

    
    
  19.             //Console.WriteLine("字符串S为空字符串：{0}", NullExten.IsNull(s)); 
    20. 

    
    
  20.  
    21. 

    
    
  21.             Console.WriteLine("字符串S为空字符串：{0}", s.IsNull()); 
    22. 

    
    
  22.             Console.ReadKey(); 
    23. 

    
    
  23.         } 
    24. 

    
    
  24.     } 
    25. 

    
    
  25. } 
    26. 

    
    
  26.  
    27. 

    
    
  27. namespace ExtensionDefine 
    28. 

    
    
  28. { 
    29. 

    
    
  29.     /// <summary> 
    30. 

    
    
  30.     /// 扩展方法定义 
    31. 

    
    
  31.     /// </summary> 
    32. 

    
    
  32.     public static class NullExten 
    33. 

    
    
  33.     { 
    34. 

    
    
  34.         // 此时扩展的类型为object，这里我是故意用object类型的 
    35. 

    
    
  35.         // 如果是为了演示，当我们为一个类型定义扩展方法时，应尽量扩展具体类型，如果扩展其基类的话 
    36. 

    
    
  36.         // 则所有继承于基类的类型都将具有该扩展方法，这样对其他类型来说就进行了“污染 
    37. 

    
    
  37.         // 子所以形成了污染，是因为我们定义的扩展方法的意图本来只想扩展某个子类。 
    38. 

    
    
  38.         // 其实下面这个方法我的意图只是想扩展string类型的，所以更好的定义方法如下： 
    39. 

    
    
  39.         //public static bool isNull(this string str) 
    40. 

    
    
  40.         //{ 
    41. 

    
    
  41.         //    return str == null; 
    42. 

    
    
  42.         //} 
    43. 

    
    
  43.          
    44. 

    
    
  44.         // 不规范定义扩展方法的方式 
    45. 

    
    
  45.         public static bool IsNull(this object obj) 
    46. 

    
    
  46.         { 
    47. 

    
    
  47.             return obj == null; 
    48. 

    
    
  48.         } 
    49. 

    
    
  49.     } 
    50. 

    
    
  50. } 
    51.
 运行结果为:
　　在注释中解释了为什么在空引用中调用扩展方法不会抛出异常的原因,对于这个原因的解释也不是我个人的猜测的,而是确实如此,其实用IL反汇编程序看看程序生成的中间代码就可以证明了,下面Main函数中生成的中间代码即IL(代码中标注红色的地方就是s.IsNull()的生成的IL代码，代码意思即是调用静态类NullExten的静态方法IsNull,此时只是把空引用s传递给该方法作为传入参数，并不是真真在空引用中调用了方法。所以就不存在抛出异常了)： 

   
   
    

    
    
  1. .method private hidebysig static void  Main(string[] args) cil managed 
    2. 

    
    
  2. { 
    3. 

    
    
  3.   .entrypoint 
    4. 

    
    
  4.   // 代码大小       43 (0x2b) 
    5. 

    
    
  5.   .maxstack  2 
    6. 

    
    
  6.   .locals init ([0] string s) 
    7. 

    
    
  7.   IL_0000:  nop 
    8. 

    
    
  8.   IL_0001:  ldstr      bytearray (7A 7A 15 5F 28 75 0A 4E 03 8C 28 75 69 62 55 5C   // zz._(u.N..(uibU\ 
    9. 

    
    
  9.                                   B9 65 D5 6C 14 6F 3A 79 1A FF )                   // .e.l.o:y.. 
    10. 

    
    
  10.   IL_0006:  call       void [mscorlib]System.Console::WriteLine(string) 
    11. 

    
    
  11.   IL_000b:  nop 
    12. 

    
    
  12.   IL_000c:  ldnull 
    13. 

    
    
  13.   IL_000d:  stloc.0 
    14. 

    
    
  14.   IL_000e:  ldstr      bytearray (57 5B 26 7B 32 4E 53 00 3A 4E 7A 7A 57 5B 26 7B   // W[&{2NS.:NzzW[&{ 
    15. 

    
    
  15.  4E 1A FF 7B 00 30 00 7D 00 )                   // 2N..{.0.}. 
    16. 

    
    
  16.   IL_0013:  ldloc.0 
    17. 

    
    
  17.   IL_0014:  call       bool ExtensionDefine.NullExten::IsNull(object) 
    18. 

    
    
  18.   IL_0019:  box        [mscorlib]System.Boolean 
    19. 

    
    
  19.   IL_001e:  call       void [mscorlib]System.Console::WriteLine(string, 
    20. 

    
    
  20.                                                                 object) 
    21. 

    
    
  21.   IL_0023:  nop 
    22. 

    
    
  22.   IL_0024:  call       valuetype [mscorlib]System.ConsoleKeyInfo [mscorlib]System.Console::ReadKey() 
    23. 

    
    
  23.   IL_0029:  pop 
    24. 

    
    
  24.   IL_002a:  ret 
    25. 

    
    
  25. } // end of method Program::Main 
    26.
四、小结
到这里本专题的内容就介绍完了，这里总结下该专题介绍的内容：
  1.  介绍了扩展方法的定义和使用，以及扩展方法定义的规则，具体可以参照第一部分
  2. 介绍了编译器是如何去发现扩展方法的，以及写了一些例子进行测试，具体可以参照第二部分
  3. 解释了为什么在空引用中可以调用扩展方法的原因，具体可以参照第三部分
在下一个专题将和大家介绍下C# 3中最重要的一个特性——Linq。