Can I invoke base for overriden method.

Question

Hi, Is it possible to invoke method A.F() from instance of B class except of using refactoring. Thanks..

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

    static void Main( string[] args )
    {
      B b = new B();  

      //Here I need Invoke Method A.F() , but not overrode..      

      Console.ReadKey();
    }
  }

Answer 1

you can use base.method() in the derived class to call the method in base class.

Answer 2

You need base.F();

Answer 3

I'm not sure if you can call the base method directly (might be a crazy trick out there that I am not aware of). As a slight alternative, can you add methods to class B? If so, add:

public void F (int i)
{
    base.F();
}

And call it using:

b.F(1);

Answer 4

You can only call the base method from within the class definition itself. So if you have a need to do it, you'll have to do it there. It may come down to you have to overload that method to call the base method from an external source (similar to how @Edward Leno mentiods).

class Program 
  { 
    public class A 
    { 
      public virtual void F(bool useBase) 
      { 
        Console.WriteLine( "A" ); 
      } 
    } 
    public class B : A 
    { 
      public override void F(bool useBase) 
      { 
        if(useBase) base.F();
        else Console.WriteLine( "B" ); 
      } 
    } 


    static void Main( string[] args ) 
    { 
        B b = new B();   

        //Here I need Invoke Method A.F() , but not overrode..       
        b.F(true);

        Console.ReadKey(); 
        } 
    }
  }

Answer 5

You may use the new keyword to have another definition of the same (named) method. Depending on the type of reference, you call A's of B's implementation.

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

static void Main( string[] args )
{
  B b = new B();  

  // write "B"
  b.F();

  // write "A"
  A a = b;
  a.F();
}

---

If you feel that new is not the right solution, you should consider to write two methods with a distinguished name.

---

Generally, you can't call the base implementation from outside the class if the method is properly overridden. This is an OO concept. You must have another method. There are four ways (I can think of) to specify this distinguished method:

• write a method with another name.
• write a method with same name but another signature (arguments). It's called overloading.
• write a new definition of the method with the same name (use the new keyword) It's called hiding.
• Put it onto interfaces and implement at least one explicitly. (similar to new, but based on interface)