C# Hiding, overriding and calling function from base class

Question

I'm learning C# and I encountered the following problem. I have two classes: base and derived:

class MyBase
{
    public void MyMethod()
    {
        Console.WriteLine("MyBase::MyMethod()");
    }
}


class MyDerived: MyBase
{
    public void MyMethod()
    {
        Console.WriteLine("MyDerived::MyMethod()");
    }
}

For now, without virtual and override key words. When I compile this I get the warning (which is of course expected) that I try to hide MyMethod from MyBase class.

What I want to do is to call the method from the base class having an instance of derived class. I do this like this:

MyDerived myDerived = new MyDerived();
((MyBase)myDerived).MyMethod();

It works fine when I do not specify any virtual, etc. keywords in the methods. I tried to put combination of the keywords and I got the following results:

| MyBase::MyMethod | MyDerived::MyMethod | Result printed on the console |
| -----------------|---------------------|-------------------------------|
| -                | -                   | MyBase::MyMethod()            |
| -                | new                 | MyBase::MyMethod()            |
| virtual          | new                 | MyBase::MyMethod()            |
| virtual          | override            | MyDerived::MyMethod()         |

I hope the table is clear to you. I have two questions:

1. Is it the correct way to call the function from the base class (((MyBase)myDerived).MyMethod();)? I know about base keyword, but it can be called only from the inside of the derived class. Is it right?
2. Why in the last case (with virtual and override modifiers) the method which was called came from the derived class? Would you please explain that?

Answer 1

When you call a virtual method on an instance of a type that overrides the method, the overridden version will always be called, even if you cast to the base class.

The only way to call the base implementation of a virtual method on a class that overrides the method is to make a second method in the derived class (not the base class) that calls the method using the base keyword.

In general, needing to do this is a sign of a poor API design - if you think you'll need to call the base version, the derived version should probably have a different name.