base与this关键字

1.base关键字

在博文《C#类继承中构造函数的用法小结》一文中，我们已经学习到：使用base关键字可以帮助子类显示地调用父类的构造函数。对于这点，我们可以使用前文所给的实例代码（有裁剪）来进行说明，具体代码如下：

[csharp] view plain copy

1. //父亲类  
2. public class FatherClass  
3. {  
4.     public FatherClass()  
5.     {  
6.          Console.WriteLine("FatherClass Constructor:FatherClass()");  
7.     }  
8.     public FatherClass(string from)  
9.     {  
10.          Console.WriteLine("FatherClass Constructor:FatherClass({0})", from);  
11.     }  
12. }  
13.   
14. //小霸王类，我是小霸王，腰里别只鸡  
15. public class MeClass : FatherClass  
16. {  
17.     public MeClass()  
18.     {  
19.         Console.WriteLine("MeClass Constructor:MeClass()");  
20.     }  
21.     public MeClass(string from)  
22.         : base(from)  
23.     {  
24.         Console.WriteLine("MeClass Constructor:MeClass({0})", from);  
25.     }  
26. }  
27.   
28. static void Main(string[] args)  
29. {  
30.      //类实例化，含参数  
31.      string from = "tiana0";  
32.      Console.WriteLine("类实例化,调用有参构造函数：");  
33.      MeClass me1 = new MeClass(from);  
34. }  

运行程序，结果如下：

代码分析：

代码中定义了子类MeClass 及父类FatherClass，子类和父类均包含两个构造函数：一个无参构造函数和一个有参构造函数。在对子类MeClass 进行实例化时，会调用该类的有参构造函数，该构造函数的声明中包含了“: base(from)”，这将告诉编译器子类需要显式地去调用父类的有参构造函数。

那么我们去掉“: base(from)”，结果又会怎样呢？

去掉“: base(from)”，再次运行程序，结果如下：

很显然，在子类被实例化时，调用的是父类的无参构造函数。这是编译器的自作主张而已，也就是说，子类若不显式的调用父类的构造函数时，编译器会自动调用父类的无参构造函数。这些，在文章《C#类继承中构造函数用法小结 》有详细说明，有不解之处，可以去查阅。

除了这点，那么base关键字还有其他什么用处吗？

答案是肯定的。使用base关键字可以帮助子类调用基类上已被其他方法重写的方法。

对于这点，我们给出下面的实例代码：

[csharp] view plain copy

1. //父亲类  
2. public class FatherClass//:GrandfatherClass  
3. {  
4.      protected string strFather = "I'm your father,gay!";  
5.      public virtual void ShowInfo()  
6.      {  
7.          Console.WriteLine("{0}", strFather);  
8.      }  
9. }  
10.   
11. //小霸王类，我是小霸王，腰里别只鸡  
12. public class MeClass : FatherClass  
13. {  
14.      private string strMe = "I'm your son,gay!";  
15.      public override void ShowInfo()  
16.      {  
17.          Console.WriteLine("{0}", strMe);  
18.      }  
19. }  
20.   
21. static void Main(string[] args)  
22. {  
23.      //类实例化  
24.      Console.WriteLine("类实例化,调用无参构造函数：");  
25.      MeClass me = new MeClass();  
26.      me.ShowInfo();  
27. }  

代码运行结果为：

代码分析：

代码中，父类定义了虚方法ShowInfo，用来输出字符串"I'm your father,gay!"，子类重写了父类方法ShowInfo，用来输出字符串"I'm your son,gay!"，在子类实例化后，调用方法ShowInfo，输出了字符串"I'm your son,gay!"。这时，你发现，父类的方法ShowInfo不再被使用了。那么我们要是想在子类中使用父类的这个被重写方法，又该怎么办呢？（哥们，还在故弄玄虚啊）很明显使用base关键字了。我们稍稍修改代码，如下：

[csharp] view plain copy

1. //小霸王类，我是小霸王，腰里别只鸡  
2. public class MeClass : FatherClass  
3. {  
4.     private string strMe = "I'm your son,gay!";  
5.     public override void ShowInfo()  
6.     {  
7.          Console.WriteLine("{0}", strMe);  
8.     }  
9.     public void ShowFatherInfo()  
10.     {  
11.          base.ShowInfo();  
12.     }  
13. }  
14.   
15. static void Main(string[] args)  
16. {  
17.     //类实例化  
18.     Console.WriteLine("类实例化,调用无参构造函数：");  
19.     MeClass me = new MeClass();  
20.     //me.ShowInfo();  
21.     me.ShowFatherInfo();  
22. }  

父亲类代码不做任何修改。

上面的代码在前面代码的基础上，为子类增加了方法ShowFatherInfo，在该方法中使用代码“base.ShowInfo();”来显式调用父类被重写的方法ShowInfo来输出字符串"I'm your father,gay!"，接着对子类进行实例化并调用新方法ShowFatherInfo，这次终于输出了字符串"I'm your father,gay!"，不信，那就看结果。

呵呵，儿子终于变成了老子，老子信了你的邪。（博主看龙门，看出毛病来了，请见谅）

到这里，base关键字的主要作用，已基本讲完。

最后，补充一点，那就是：从静态方法中使用 base 关键字是错误的。（msdn）

对于这点，就不举例说明了，下面展开this关键字的介绍。

2.this关键字

this关键字的第一个作用为：限定被相似的名称隐藏的成员(msdn)。

[csharp] view plain copy

1. //小霸王类，我是小霸王，腰里别只鸡  
2. public class MeClass  
3. {  
4.     private string name;  
5.     public MeClass(string name)  
6.     {  
7.          this.name = name;                      
8.     }  
9. }  

在实例代码中，类的私有成员变量name与类成员方法的入参名称相同，所以，在函数体中，类的私有成员变量name被入参name隐藏，要想在函数体中使用该私有成员变量，需要使用this关键字来指定，“this.name”的作用就是告诉编译器，此处的name为类的私有成员变量而不是函数的入参name。

this关键字的第二个作用为：将对象作为参数传递到其他方法（msdn）。

[csharp] view plain copy

1. public class ClassHelper  
2. {  
3.     MeClass me=new MeClass();  
4.     public ClassHelper(MeClass me)  
5.     {  
6.         this.me = me;  
7.     }  
8. }  

[csharp] view plain copy

1. //小霸王类，我是小霸王，腰里别只鸡  
2. public class MeClass : FatherClass  
3. {  
4.      public MeClass()  
5.      {  
6.           ClassHelper ch = new ClassHelper(this);  
7.      }        
8. }  

实例代码中，MeClass得构造函数中对类ClassHelper 进行实例化，传入参数为this，此处的this代表MeClass对象。这里所取实例并没有任何价值，甚至有点牵强，但是能说明问题就好。

this关键字的第三个作用为：声明索引器（msdn）。

对于这点，我就不做太多说明，主要是暂时我还很少涉及到索引器，以后有机会再作补充。暂时给出msdn上的实例链接：http://msdn.microsoft.com/zh-cn/library/dk1507sz.aspx

this关键字的第三个作用为：可用作扩展方法的第一个参数的修饰符(msdn)。

关于这点，博主在其他关于扩展方法的几篇文章已经有详细说明，想了解这点的同志们请查阅以下文章：

1.C#扩展方法初探 http://blog.csdn.net/yl2isoft/article/details/9528445

2.扩展方法入门 http://blog.csdn.net/yl2isoft/article/details/9734385

3.C#扩展方法调用简析http://blog.csdn.net/yl2isoft/article/details/9915263

4.C# Linq扩展方法应用http://blog.csdn.net/yl2isoft/article/details/9996889

最后，还是需要补充一点，那就是：由于静态成员函数存在于类一级，并且不是对象的一部分，因此没有 this 指针。在静态方法中引用 this是错误的。（msdn）

好了，就写到这里。