Преимущества вызова метода с использованием базового указателя

Question

я реализовал метод в базовом классе следующим образом:

class A 
    { 
     protected void f1() 
     { 

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

    } 

В чем разница между вызовом просто и вызовом с использованием базового указателя? Каковы преимущества любого из способов?

Answer 1

В этом случае нет. Но представьте себе:

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 2

Разница между 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 3

Это полезно только если вы перегрузили/слежку метод, определенный в базовом классе.

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 4

Основание ключевое слово используется для обозначения базового класса, когда сцепление конструкторов или когда вы хотите получить доступ к члену (метод, свойство, что угодно) в базовом классе, который был переопределен или скрытой в текущем классе , Например,

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 5

, если переопределить 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(); 
    } 

} 

Answer 6

В вашем примере нет разницы. Тем не менее, рассмотрим ситуацию, когда 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 7

Также полезно, если вы хотите расширить функциональность базового метода, но не хотите повторить его:

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" 
     } 
    }