Overloading,Overriding and Hiding? [closed]

Question

can anyone explain what is Overloading, Overriding and Hiding in .Net?

Thanks

Answer 1

Overloading is the definition of multiple possible "signatures" of a single method or operator. Each signature takes different arguments, and is essentially a distinct function, no different than if the multiple functions had different names. This is often used to group conceptually similar operations, such as overloading + to work with BigInteger and with String: both operations seem sensible to use + for (unless you think that all overloads of + should define Abelian groups -- the String overload doesn't).

Overriding is the definition of multiple possible implementations of the same method signature, such that the implementation is determined by the runtime type of the zeroth argument (generally identified by the name this in C#).

Hiding is the definition of a method in a derived type with a signature identical to that in one of its base types without overriding.

The practical difference between overriding and hiding is as follows:

• If a method is overridden, the implementation to call is based on the run-time type of the argument this.
• If a method is simply hidden, the implementation to call is based on the compile-time type of the argument this.

Answer 2

Overloading is providing multiple methods with the same name and different signatures:

void Foo() {...}
void Foo(int i) {...}

Overriding is used in inheritance to change the implementation per subclass:

class SomeBase {
    public virtual void Foo() {}
}
class SomeOther : SomeBase {
    public override void Foo() {
        // different implementation, possibly calling base.Foo();
    }
}

With the above, even if I do:

SomeBase obj = new SomeOther();
obj.Foo();

it will call the SomeOther.Foo implementation. The method called depends on the instance type, not the variable.

Method hiding is the opposite; it replaces the method signature, but only applies if you call the method from the derived type:

class SomeBase {
    public void Foo() {}
}
class SomeOther : SomeBase {
    public new void Foo() {
        // different implementation, possibly calling base.Foo();
    }
}

Now:

SomeOther obj = new SomeOther();
SomeBase baseObj = obj;
obj.Foo(); // calls SomeOther.Foo
baseObj.Foo(); // calls SomeBase.Foo

i.e. the method calls depends on the variable, not the instance.