What is Shadowing?

Question

Shadowing hides a method in a base class. Using the example in the question you linked:

class A 
{
   public int Foo(){ return 5;}
   public virtual int Bar(){return 5;}
}
class B : A
{
   public new int Foo() { return 1;}
   public override int Bar() {return 1;}
}

Class B overrides the virtual method Bar. It hides (shadows) the non-virtual method Foo. Override uses the override keyword. Shadowing is done with the new keyword.

In the code above, if you didn't use the new keyword when defining the Foo method in class B, you would get this compiler warning:

'test.B.Foo()' hides inherited member 'test.A.Foo()'. Use the new keyword if hiding was intended.

• Overriding : redefining an existing method on a base class
• Shadowing : creating an entirely new method with the same signature as one in a base class

Suppose I have a base class that implements a virtual method:

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

I also have a derived class that also defines a method M:

public class B : A
{
    // could be either "new" or "override", "new" is default
    public void M() { Console.WriteLine("In B.M()."); }
}

Now, suppose I write a program like this:

A alpha = new B(); // it's really a B but I cast it to an A
alpha.M();

I have two different choices for how I want that to be implemented. The default behavior is to call A's version of M. (This is identical to the behavior if you applied the "new" keyword to B.M().)

This is called "shadowing" when we have a method with the same name but a different behavior when called from the base class.

Alternately, we could have specified "override" on B.M(). In this case, alpha.M() would have called B's version of M.

Shadowing consist on hiding a base class method with a new definition in a child class.

The difference between hiding and overriding has to do with the way methods are invoked.

That way, when a virtual method is overridden, the call address for the method call table of the base class is replaced with the address of the child routine.

On the other hand, when a method is hidden, a new address is added to the method call table of the child class.

When a call is made to the method in question:

1. The method call table class type is obtained, if we are invoking with a reference to the base class then the base class method table is obtained, if we have a reference to the child class, then the child class method table is obtained.
2. The method is searched in the table, if it's found then the invocation takes place, otherwise the base class method table is searched.

If we invoke the method with a reference to the child class then the behavior is the same, if the method has been overridden, the method address will be found in the base class, if the method was hidden the method address will be found on the child class, and since it has been already found, base class table will not be searched.

If we invoke the method with a reference to the base class then behavior changes. When overriding, as the method address overwrites base class entry, we will call the child method, even when holding a reference to the base class. With shadowing, the base class method table (which is the only one visible as we hold a reference to the base class) contains the virtual method address, and therefore, the base class method will be called.

In general shadowing is a bad idea, as it introduces a difference on the behavior of an instance depending on the reference we have to it.

Expanding on Kent's correct answer

When disambiguating when which method will be called, I like to think of shadowing vs. overriding with the following

• Shadowing: The method called depends on the type of the reference at the point the call is made
• Overriding: The method called depends on the type of the object at the point the call is made.

Here's an MSDN article on Shadowing. The language examples are in Visual Basic (unfortunately there is no equivalent C# page on MSDN), but it deals generally with the concepts and hopefully should help you understand anyway.

Edit: Seems like there is a C# article on shadowing, except that it's called hiding in C#. Also, this page offers a good overview.