base想到...


base 是C#中77个(如果没有记错的话)关键字之一,在MSDN文档中列举的主要作用是两个:
1. 调用基类上已被其他方法重写的方法。
2. 指定创建派生类实例时应调用的基类构造函数。

注意点:基类访问只能在构造函数、实例方法或实例属性访问器中进行,从静态方法中使用base关键字是错误的。


对于第1点,作用十分明显,重写了父类函数,但是又需要调用父类函数的时候就需要用到了,例如下面的代码:

using System;

class BaseClass
{
    
public BaseClass()
    
{
        Console.WriteLine(
"[BaseClass.BaseClass] " + 
           
"Constructor called");           
    }

    
    
public BaseClass(int foo)
    
{
            Console.WriteLine(
"[BaseClass.BassClass] " +
               
" Argument parameter is {0}", foo.ToString());    
    }

    
    
public virtual void PrintInfo()
    
{
            Console.WriteLine(
"[BaseClass.BaseClass] " + 
                
" PrintInfo method Invoked! ");    
    }

    
    
}


class DerivedClass : BaseClass
{
    
public DerivedClass() : base(100)
    
{
        Console.WriteLine(
"This");    
    }

    
    
public DerivedClass(int foo) : this()
    
{        
        Console.WriteLine(
"[DerivedClass.Derived] " +
             
"Constructor called");
    }

    
    
public override void PrintInfo()
//        public void PrintInfo()
    {
//        base.PrintInfo();
            Console.WriteLine("[DerivedClass.Derived] " +
                 
" PrintInfo method Invoked!!!");    
    }

}


class DefaultInitializer
{
    
public static void Main()
    
{
        Console.WriteLine(
"[Main] Instantiating a " +
           
"DerivedClass object");
        DerivedClass derived 
= new DerivedClass(100);
        derived.PrintInfo();
    }

}
        

结果和作用都是大家预期的。

用ildasm来看一下,这个过程在IL代码中是如何进行的?

调用override的函数,是指回去父类中去的,但是调用的代码效果却又不是父类中的代码,呵呵~~

而在没有override时候呢, 则是这样的:


重写后的函数调用父类在增加了base.PrintInfo();后在IL可以看到,其实它是直接调用父类中函数的:
增加了base.PrintInfo();后:


没有增加:


可见重写函数中是直接调用父类对应函数的。

两层类结构的IL代码如此,那么三层呢?IL出现的是最上层的类调用还是父类调用呢?
用下面的代码:

using System;

class BaseClass
{
    
public BaseClass()
    
{
        Console.WriteLine(
"[BaseClass.BaseClass] " + 
           
"Constructor called");           
    }

    
    
public BaseClass(int foo)
    
{
            Console.WriteLine(
"[BaseClass.BassClass] " +
               
" Argument parameter is {0}", foo.ToString());    
    }

    
    
public virtual void PrintInfo()
    
{
            Console.WriteLine(
"[BaseClass.BaseClass] " + 
                
" PrintInfo method Invoked! ");    
    }

    
    
}


class DerivedClass : BaseClass
{
    
public DerivedClass() : base(100)
    
{
        Console.WriteLine(
"This");    
    }

    
    
public DerivedClass(int foo) : this()
    
{        
        Console.WriteLine(
"[DerivedClass.Derived] " +
             
"Constructor called");
    }

    
    
public override void PrintInfo()
//        public void PrintInfo()
    {
        
base.PrintInfo();
            Console.WriteLine(
"[DerivedClass.Derived] " +
                 
" PrintInfo method Invoked!!!");    
    }

}


class DerivedClass2 : DerivedClass
{
    
public DerivedClass2() : base(100)
    
{
        Console.WriteLine(
"This");    
    }

    
    
public DerivedClass2(int foo) : this()
    
{        
        Console.WriteLine(
"[DerivedClass.Derived] " +
             
"Constructor called");
    }

    
    
public override void PrintInfo()
//        public void PrintInfo()
    {
        
base.PrintInfo();
            Console.WriteLine(
"[DerivedClass2.Derived] " +
                 
" PrintInfo method Invoked222!!!");    
    }

}


class DefaultInitializer
{
    
public static void Main()
    
{
        Console.WriteLine(
"[Main] Instantiating a " +
           
"DerivedClass object");
        DerivedClass2 derived 
= new DerivedClass2(100);
        derived.PrintInfo();
    }

}
        



       从IL代码看到,它依然指向了最高层次的那个父类的。但如果此时增加base.PrintInfo()代码,却依然如我们希望的那样只是调用父类DerivedClass2的相关函数。

重写父类一般的函数的这种方式到了IL这个层面的原来是如此的,是否和想象中的不同?




       对于第2种情况,当父类的构造函数需要带参数的,且情况比较复杂时候,用base来显式说明具体调用需要的构造函数是十分方便的,如果不特别指定则缺省调用不带参数的那个,如果父类没有这个不带参数的构造函数则会出错的。代码如上面的例子也可见一斑。

       问题是如果希望和一般函数重写那样,到子类的构造函数完全不需要父类的构造函数方式呢?构造函数似乎不可以写成override的方式的。

       想到增加一个决定父类如何构造的参数,父类根据子类传入的参数来决定如何初始化,但是这样初始化最终决定权还是在父类那边,代码如下:

using System;

enum ClassType
{
    NoneInit,
    Init1,
    Init2
}


class BaseClass
{

    
public BaseClass(ClassType aType)
    
{
           
switch(aType)
           
{
              
case ClassType.NoneInit:
                 
break;
              
case ClassType.Init1:
                 
break;
              
case ClassType.Init2:
                 
break;
              
default:                 
                 
break;    
           }

    }

}

    
       有没有象override那样的实现机制呢,继承的子类比较灵活,即使有改动对父类更改也不多?

 

 

 


 

posted on 2004-10-28 16:02  风前絮~~  阅读(1864)  评论(1编辑  收藏  举报

导航