Can anybody tell the working of overriding and hiding in terms of memory and references.
class A
{
public virtual void Test1() { //Impl 1}
public virtual void Test2() { //Impl 2}
}
class B : A
{
public override void Test1() { //Impl 3}
public new void Test2() { Impl 4}
}
static Main()
{
A aa=new B() //This will give memory to B
aa.Test1(); //What happens in terms of memory when this executes
aa.Test2(); //-----------------------SAME------------------------
}
Here memory is with class B but in the second statement aa.Test2 class A's method will be called. Why is it? If B has memory then B's method should be called (in my point of view).
Any link / exercise that describes this fundamental very deeply and completely will be a big help.
Take a look at this answer to a different question by Eric Lippert.
To paraphrase (to the limits of my comprehension), these methods go into "slots".
A
has two slots: one forTest1
and one forTest2
.Since
A.Test1
is marked asvirtual
andB.Test1
is marked asoverride
,B
's implementation ofTest1
does not create its own slot but overwritesA
's implementation. Whether you treat an instance ofB
as aB
or cast it to anA
, the same implementation is in that slot, so you always get the result ofB.Test1
.By contrast, since
B.Test2
is markednew
, it creates its own new slot. (As it would if it wasn't markednew
but was given a different name.)A
's implementation ofTest2
is still "there" in its own slot; it's been hidden rather than overwritten. If you treat an instance ofB
as aB
, you getB.Test2
; if you cast it to anA
, you can't see the new slot, andA.Test2
gets called.Deducting from the code provided you should have
B:A
.You can hide a method in case when you want create your own implementation of the (say) method of the base class, which can not be overriden, cause, say, it's not
virtual
.In my expirience, I used hiding mostly for
debug
purposes.For example when I don't know who sets the property of some 3rd prt
component
, whom code is not available to me. So what I do is:new
keywordset
Sometimes, very useful and helps me get information in fast way, especially in first stage when you're learning new
components
,frameworks
,libraries
.. whatever.Method Hiding is that when Base Class reference variable pointing to a child class object. It will invoke the hidden method in base Class.
Where as, When We declare virtual method in the base class. We override that method in the derived or child class. Then Base Class reference variable will call the derived class method. This is called Method Overriding.
To add to @Rawling's answer, practical examples could be shown using an example such as this:
1. Overriding
In case of the overriden property, base class' virtual method's slot is replaced by a different implementation. Compiler sees the method as virtual, and must resolve its implementation during run-time using the object's virtual table.
2. Hiding
When a method or a property is hidden using the
new
keyword, the compiler creates a new non-virtual method for the derived class only; base class' method remains untouched.If the type of the variable is
Base
(i.e. only contains the virtual method), its implementation will be resolved through the vtable. If the type of the variable isNew
, then the non-virtual method or property will be invoked.3. Summary
If a part of your code accepts the base type, it will always use the virtual table during run-time. For most OOP scenarios, this means that marking a method as
new
is very similar to giving it a completely different name.4. Object sizes after instantiation
Note that instantiating any of these types doesn't create a copy of the virtual table. Each .NET object has a couple of bytes of header and a pointer to the virtual table of table of its type (
class
).Regarding the
new
property (the one which is not virtual), it is basically compiled as a static method with thiscall semantics, meaning that it also doesn't add anything to the size of the instance in memory.Test1() method in class A and test1() method in class B will executes according to MethdOverriding.
Test2() method in class A and test2() method in class B will executes according to Method Hiding.
In method Overriding the child class members will execute, and in Method Hiding the Parent class members will execute.
Already answered at here
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:
Hiding is for all other members (static methods , instance members, static members). It is based on the early binding . More clearly , the method or member to be called or used is decided during compile time.
•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.
Here are some samples : Example # 1. and Example # 2