Question

我在基类中实现了如下方法：

  class A
    {
        protected void f1()
        {

        }
    }
    class A1 : A
    {
        public void f2()
        {
           //Simple Calling
            f1();
           //Calling using base pointer
            base.f1();
        }

    }

简单调用和使用基指针调用有什么区别？两种方式的优点是什么？

Answer 1

在你的例子中没有区别。但是，请考虑f1是虚拟的情况，并且它在A1类中有另一个实现：

class A
{
    protected virtual void f1()
    {
        Console.WriteLine("A");
    }
}

class A1 : A
{
    public void f2()
    {
       //Simple Calling - prints `A1`
        f1();
       //Calling using base pointer - prints `A`
        base.f1();
    }

    protected override void f1()
    {
        Console.WriteLine("A1");
    }
}

f1()与base.f1()不同。当您使用new关键字隐藏派生类中的基本实现时，会出现相同的情况：

protected new void f1()
{
    Console.WriteLine("A1");
}

Answer 2

在这种情况下，没有。但想象一下：

class A 
{ 
    public virtual void F() 
    {
    } 
}
class B : A 
{ 
   public override void F() 
   { 
       Console.WriteLine("B"); 
   } 
   public void F2() 
   { 
       F(); /*output: B*/ 
       base.F() /*no output*/ 
   } 
}

这就是base开始有用的地方。

Answer 3

当您覆盖虚拟方法时，this.f1()（或简称f1()）与base.f1()之间的差异变得相关：

class A
{
    public virtual void F()
    {
        Console.WriteLine("A");
    }
}

class B : A
{
    public override void F()
    {
        Console.WriteLine("B");
    }

    void Test()
    {
        F(); // Prints "B"
        this.F(); // Prints "B"
        base.F(); // Prints "A"
    }
}

Answer 4

只有在重载/阴影基类中定义的方法时才有用。

class A1 : A
{
    public void f2()
    {
       //Simple Calling
        f1();
       //Calling using base pointer
        base.f1();
    }

    protected new void f1()
    {
        // I won't be called
    }

}

Answer 5

当您想要扩展基本方法的功能但又不想复制它时也很有用：

class A
{
    public virtual void F()
    {
        Console.WriteLine("A");
    }
}

    class B : A
    {
        public override void F()
        {
            base.F();
            Console.WriteLine("B");
        }

        void Test()
        {
            F(); // Prints "A B"
        }
    }

Answer 6

base关键字用于在链接构造函数时或在您想要访问已在当前类中重写或隐藏的基类中的成员（方法，属性，任何内容）时引用基类。例如，

class A {
    protected virtual void Foo() {
        Console.WriteLine("I'm A");
    }
}

class B : A {
    protected override void Foo() {
        Console.WriteLine("I'm B");
    }

    public void Bar() {
        Foo();
        base.Foo();
    }
}

有了这些定义，

new B().Bar();

会输出

I'm B
I'm A

<强> Reference

Answer 7

如果你覆盖f1，则需要根据它来区分它们。

class A
{
    protected virtual void f1() {   }
}
class A1 : A
{
    protected override void f1() {   }

    public void f2()
    {
       //Simple Calling
        f1();                 <--- this will call to overrided f1 in this class
       //Calling using base pointer
        base.f1();
    }

}

使用基指针调用方法的优点

7 个答案: