What is the difference between method hiding and shadowing in C#?

Question

What is the difference between method hiding and shadowing in C#? Are they same or different? Can we call them as polymorphism (compile time or run time)?

Icecold

No, that's a different comparison. – Komsomolsk

Answer 1

What is the difference between method hiding and shadowing in C#?

Shadowing is another commonly used term for hiding. The C# specification only uses "hiding" but either is acceptable.

You call out just "method hiding" but there are forms of hiding other than method hiding. For example:

namespace N
{   
    class D {}
    class C 
    {
        class N
        {
            class D
            {
                 N.D nd; // Which N.D does this refer to?

the nested class N hides the namespace N when inside D.

Can we call them as polymorphism (compile time or run time)?

Method hiding can be used for polymorphism, yes. You can even mix method hiding with method overriding; it is legal to introduce a new virtual method by hiding an old virtual method; in that case which virtual method is chosen depends on the compile-time and run-time type of the receiver. Doing that is very confusing and you should avoid it if possible.

Adulterate

You said "Method hiding can be used for polymorphism, yes". Then it is compile time or runtime polymorphism? – Icecold

@ShaileshJaiswal: Read the sentence which follows that sentence. – Adulterate

Thanks Eric got your point. I read this article dotnet-guide.com/what-do-you-mean-by-shadowing-in-dot-net.html. Can method hiding have different signatures in base class and derived class ? – Icecold

@ShaileshJaiswal: A "new" method should have the exact same signature as the method it is hiding; if it does not then the compiler will give you a warning noting that the "new" is unnecessary. – Adulterate

Answer 2

The VB.NET compiler calls it shadowing, in C# it is called hiding. Calling it shadowing in C# is a spill-over from VB.

And it is a a compiler warning, it essentially is a name-conflict between base and derived class.

Can we call them as polymorphism (compile time or run time)?

It certainly is not a form of runtime polymorphism. A call to a hiding or to a hidden method is resolved at compile time. Which makes that it will in general not be called or considered polymorphism.

Drislane

Answer 3

The two terms mean the same in C#.

Method hiding == shadowing.

You can use this as a form of polymorphism - when you don't want the base class method to be visible/usable through the inheriting class.

A shadowing method is completely decoupled from the base class - it is a new method. The term hiding is used because it has an identical signature to the one of the base class and is "hiding" it - it breaks the inheritance chain.

Sprue

To futher clarify, method calls of this type are determined at compile-time (static binding). If you want run-time evaluation or dynamic binding you must use virtual (and override in the child class). The compile-time evaluation I'd argue isn't polymorphic code at all, but I'm sure others have different opinions. – Bluebird

@Bluebird - virtual and override. – Sprue

Answer 4

They are just two different words for the same thing, but differ in the context where you most often use them. Typically, what is called "hiding" is related to polymorphism but what is called "shadowing" is not.

In C# parlance, when you say "hiding" you're usually talking about inheritance, where a more derived method "hides" a base-class method from the normal inherited method call chain.

When you say "shadow" you're usually talking about scope: an identifier in an inner scope is "shadowing" an identifier at a higher scope. In other languages, what is called "hiding" in C# is sometimes called "shadowing" as well.

Both are compile-time concepts; they describe what object a given identifier refers to in a given context when the compiler goes to bind it.

public class A
{
  public int B;
  public void C()
  {
    return this.B;
  }
}

public class D : A
{
  public int X;

  public new void C()
  {
    var X = 1.0m;
    return X;
  }
}

Method D.C() "hides" method A.C(); normally, a call to D.C() would always call into the base classes A.C() method, since it's not virtual. We don't want that; we want D.C(). Obviously this is something you should try to avoid, because it's confusing, especially if you start up-casting your D's to A's, but it exists if you need it. Also, note that method hiding is automatic: without the new keyword here, D.C() still hides A.C() but we get a warning because usually that's not what you want. The new keyword just makes it clear that is really is what we want.

Local variable X in D.C() shadows class member D.X within the scope of D.C() only. In this case, there are two things in scope that could legitimately be called X and the compiler needs rules to tell it which one you mean. The "more local" X shadows the "less local" D.X so that's what we get.

Dahabeah

Answer 5

Name hiding of C# (new modifier) is called shadowing in VB.NET (keyword Shadows).

This can be thought of as polymorphism only in the sense that overriding is a "polymorphism", i.e. static or compile-time. It is not a polymorphism in the classical sense of calling virtual functions.

Datary