How can I override a virtual method, but still invoke the base class version in C#

I have a simple class hierarchy where I have a virtual method that is overriden. But开发者_C百科 at certain callsites I want to call the base class version of this method rather than the virtual method.

For example:

public class A {
    public virtual void Foo() {...}
}

public class B : A {
    public override void Foo() {...}
}

public class Program {
    public void SomeMethod()
    {
       ...

       //  ListofA is type IEnumerable<A>
       foreach (var item in ListofA)
       {
           // I want this to call A.Foo(), rather than B.Foo()
           // But everything I've tried, which has really just been casting, has resulted in B.Foo()
           item.Foo();
       }
    }
}

You can't on an override. Overrides replace the original (from the standpoint of the caller). An overridden method may call the base, but you can't externally.

@James is right. To build on his answer, since you can call the base version from the overridden one, you could send some kind of a flag into the method to tell it whether to execute its own implementation or the overridden one. Something like this:

public override void Foo(bool useBaseImplementation)
{
    if(useBaseImplementation)
    {
        base.Foo(useBaseImplementation);
    }
    else
    {
        //other stuff here
    }
}

In order for it to work, you'd have to have the flag as a parameter for the base one as well, but you could just ignore it there. Not elegant, maybe downright ugly, but does what you're looking for.

If this is the case then what you want isn't actually an override; you should rethink your design. If instead of override you use new in the redefinition the method won't be polymorphic, but again, this is highly indicative of a flawed design. You would also need foreach (A item in ListofA)

I don't like my solution, beacause it sorta uglifies abstration, but maybe you could do the following:

public class A {
  public virtual void Foo() {...}
}

public class B : A {
  public override void Foo() {...}
  public override void parentFoo(){
    base.Foo();
  }
}

public class Program {
  public void SomeMethod(){
    ...

     //  ListofA is type IEnumerable<A>
     foreach (var item in ListofA){
       item.Foo(); //calls B.Foo()
       item.parentFoo(); //calls B.parentFoo() == A.Foo()
     }
  }
}

If var item = new A(), it will call A.Foo().

You can call base implementation using the base keyword INSIDE the class, but if You are trying to call it from the other class I am pretty sure You are violating a Liskov Substitution Principle in Your code, as Any subclass shoudl provide such an implementation to virutal methods to be completely substitutable for superclass. Revisit YOUR design.

You can achieve that with using new rather than override. It is very well explained here: http://msdn.microsoft.com/en-us/library/ms173153%28v=vs.80%29.aspx

One possible workaround is not to make the method virtual, but replace it using the new keyword:

   class Program
{
    static void Main(string[] args)
    {
        List<A> list = new List<A>
        {
            new B(),
            new B(),
            new B(),
            new B()
        };

        foreach (A a in list)
        {
            a.Foo();
        }

        foreach (B b in list)
        {
            b.Foo();
        }

        Console.ReadLine();
    }
}

public class A
{
    public void Foo()
    {
        Console.WriteLine("Base");
    }
}

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

This will only call the B.Foo() implementation if the reference you use is of type B. I wouldn't encourage you to do this, since I've never came accross a situation where the new keyword made sense.