1. Introduction

In our previous parts of the learning OOP series, we were talking more about compile time polymorphism, params keyword, inheritance, base keyword, etc. This part of the article series will focus more on run time polymorphism also called late binding. We’ll use the same technique of learning, less theory and more hands-on. We’ll take small code snippets to learn the concept more deeply. To master this concept is like learning more than 50% of OOP.

https://www.codeproject.com/KB/cs/774578/runtime.jpg

2. Pre-requisites

Since this is the third part of the series, I expect my readers to be experts in compile time polymorphism and inheritance. Although it doesn’t matter if you are directly starting to learn from this article, you can take the other articles later.

3. Roadmap

Our roadmap as defined for learning OOP is clear, but let’s just revise it:

4. Runtime Polymorphism or Late Binding or Dynamic Binding

In simple C# language, in run time polymorphism or method overriding, we can override a method in base class by creating similar method in derived class this can be achieved by using inheritance principle and using “virtual & override” keywords.

5. What are New and Override Keywords in C#?

Create a console application named InheritanceAndPolymorphism in your Visual Studio.

Just add two classes and keep the Program.cs as it is.The two classes will be named ClassA.cs and ClassB.cs and add one method in each class as follows:

Program.cs

We see both classes ClassA and ClassB have the same number of methods with similar names in both the classes. Now let’s inherit ClassA from ClassB, and create instances of the classes and call their methods in program.cs.

Output

Warnings

'InheritanceAndPolymorphism.ClassA.AAA()' hides inherited member
'InheritanceAndPolymorphism.ClassB.AAA()'. Use the new keyword if hiding was intended.
'InheritanceAndPolymorphism.ClassA.BBB()' hides inherited member
'InheritanceAndPolymorphism.ClassB.BBB()'. Use the new keyword if hiding was intended.
'InheritanceAndPolymorphism.ClassA.CCC()' hides inherited member
'InheritanceAndPolymorphism.ClassB.CCC()'. Use the new keyword if hiding was intended.

Point to remember: In C#, We can equate an object of a base class to a derived class but not vice versa.

Class ClassB is the super class of class ClassA. That means ClassA is the derived class and ClassB is the base class. The class ClassA comprises ClassB and something more. So we can conclude that object of ClassA is bigger than object of ClassB. Since ClassA is inherited from ClassB, it contains its own methods and properties. Moreover, it will also contain methods/properties that are inherited from ClassB too.

Let’s take the case of object y. It looks like ClassB and initialized by creating an object that also looks like ClassB, well and good. Now, when we call the methods AAA and BBB and CCC through the object y, we know that it will call them from ClassB.

Object x looks like that of ClassA, i.e., the derived class. It is initialized to an object that looks like ClassA. When we call AAA, BBB and CCC method through x, it calls AAA, BBB and CCC from ClassA.

Now there is a somewhat tricky situation we are dealing with:

Object z again looks like ClassB, but it is now initialized to an object that looks like ClassA which does not give an error as explained earlier. But there is no change at all in the output we get and the behavior is identical to that of object y.Therefore initializing it to an object that looks like ClassB or ClassA does not seem to matter.

6. Experiment

Let’s experiment with the code, and put override behind AAA and new behind BBB methods of ClassA, i.e., the derived class.

Output

Point to remember: The override modifier is needed as the derived class methods will get first priority and be called upon.

We see here that there is only a single small change in the workings of the object z only and not in x and y. This strange output occurred only after we added virtual modifier in the base class methods. The difference is in the object z. z looks like the base class ClassB but is initialized to an instance that looks like that of derived class ClassA. C# knows this fact. When we run z.AAA(), C# remembers that instance z was initialized by a ClassA object and hence it first goes to class ClassA, too obvious. Here the method has a modifier override which literally means, forget about the data type of z which is ClassB, call AAA from ClassA as it overrides the AAA of the base class. The override modifier is needed as the derived class methods will get first priority and be called upon.

We wanted to override the AAA of the base class ClassB. We are infact telling C# that this AAA is similar to the AAA of the one in base class.

New keyword acts in the exact opposite to override keyword. The method BBB as we see has the new modifier. z.BBB() calls BBB from ClassB and not ClassA. New means that the method BBB is a new method and it has absolutely nothing to do with the BBB in the base class. It may have the same name i.e. BBB as in the base class, but that is only a coincidence. As z looks like ClassB, the BBB of ClassB gets called even though there is a BBB in ClassA. When we do not write any modifier, then it is assumed that we wrote new. So every time we write a method, C# assumes it has nothing to do with the base class.

Point to remember: These modifiers like new and override can only be used if the method in the base class is a virtual method. Virtual means that the base class is granting us permission to invoke the method from the derived class and not the base class. But, we have to add the modifier override if our derived class method has to be called.

7. Run Time Polymorphism with Three Classes

Let’s get into some more action. Let’s involve one more class in the play. Let’s add a class named ClassC, and design our three classes and program.cs as follows:

Output

Don’t be scared of the long example that we have taken. This will help you to learn the concept in detail. We have already learned that we can initialize a base object to a derived object. But vice versa will result into error. This leads to an instance of a base class being initialized to an instance of the derived class. So the question is now that which method will be called when. The method from the base class or from the derived class.

Point to remember: If the base class object declared the method virtual and the derived class used the modifier override, the derived class method will get called. Otherwise the base class method will get executed. Therefore for virtual methods, the data type created is decided at run time only.

Point to remember: All the methods not marked with virtual are non virtual, and the method to be called is decided at compile time, depending upon the static data type of the object.

If the object of a class is initialized to the same data type, none of the above rule would apply. Whenever we have a mismatch, we always need rules to resolve the mismatch. So we can land up with a scenario where an object to a base class can call a method in the derived class.

The object y that looks like of ClassB but is initialized here to the derived class, i.e., ClassA.

y.AAA() first looks into the class ClassB. Here, it verifies whether the method AAA is marked virtual. The answer is an emphatic no and hence everything comes to halt and the method AAA gets called from class ClassB.

y.BBB also does the same thing, but the method now is defined virtual in class ClassB. Thus C# looks at the class ClassA, the one it was initialized to. Here BBB is marked with the modifier “new”. That means BBB is a new method which has nothing to do with the one in the base class. They only accidentally share the same name. So as there is no method called BBB (as it is a new BBB) in the derived class, the one from base class gets called. In the scene of y.CCC(), the same above steps are followed again, but in the class ClassA, we see the modifier override, that by behaviour overrides the method in the base class. We are actually telling C# to call this method in class ClassA and not the one in the base class, i.e., ClassB.

I just got this picture from the internet that depicts our current situation of classes. We are learning the concept like charm now. OOP is becoming easy now.

The object x which also looks like that of class ClassB is now initialized with an object that looks like our newly introduced class ClassC and not ClassA like before. Since AAA is a non virtual method, it gets called from ClassB. In the case of method BBB, C# now looks into class ClassC. Here, it does not find a method named BBB and so ultimately propagates and now looks into class ClassA. Therefore the above rules repeat on and on and it gets called from class ClassB. In the case of x.CCC, in class ClassC, it is already marked new by default and therefore this method has nothing to do with the one declared in class ClassB. So the one from ClassC does not get called but the one from class ClassB where it is marked as override.

Now if we modify a bit our CCC method in ClassC and change it to the code as shown below:

publicoverridevoid CCC()
{
Console.WriteLine("ClassC CCC");
}

We changed default new to override, the CCC of ClassC will now be called.

The last object z looks like that of ClassA but is now initialized to an object that looks like the derived class ClassC, we know we can do this. So z.AAA() when called, looks first into class ClassA where it is flagged as virtual. Do you recall that AAA is non virtual in class ClassB but marked as a virtual in ClassA. From now on, the method AAA is virtual in ClassC also but not in class ClassB. Virtual always flows from upwards to downwards like a waterfall. Since AAA() is marked virtual, we now look into class ClassC. Here it is marked override and therefore AAA() gets called from class ClassC. In the case of BBB(), BBB() is marked virtual in class ClassB and new in ClassA, but as there is no method BBB in ClassC, none of the modifier matters at all in this case. Finally it gets invoked from class ClassA. At last for method CCC, in class ClassC it is marked as new. Hence, it has no relation with the CCC in class ClassA which results in method CCC gets invoked from ClassA but not ClassB.

In the above example, the code is very much self explanatory, the output which we’ll get is:

Error: 'InheritanceAndPolymorphism.C.X()': cannot override inherited member
'InheritanceAndPolymorphism.B.X()' because it is not marked virtual, abstract, or override

Strange! We got an error as the method X() in class B is marked new. That means it hides the X() of class A. If we talk about class C, B does not supply a method named X. The method X defined in class B has nothing to do with the method X defined in class A. This means that the method X of class B does not inherit the virtual modifier from the method X() of class A. This is what the compiler complained about. As the method X in B has no virtual modifier, in C we cannot use the modifier override. We can, however, use the modifier new and remove the warning?

Output

Class: A ; Method X
Class: C ; Method X

If in the above code, we remove the modifier override from X() in class C, we get:

Output

Class: A ; Method X
Class: B ; Method X

Yes, that’s the problem with virtual methods. Sometimes, they are too confusing, the result is entirely different with what we expect. Object a looks like an A but is initialized to the derived class C. Since X is virtual, C# now goes and looks into class C. But before looking into the class C, it realizes that in class B, X is new. That’s it, this thing cuts of all connection with the X in A. Thus the keyword new is preceded with virtual, otherwise the override modifier would give us an error in class C. As X in class B is marked as new method, having nothing to do with the class A, class C inherits a new which also has nothing to do with the class A. The X in class C is related to the X of class B and not of class A. Thus the X of class A gets invoked.

In the second case, object b looks like class B now but in turn is initialized to an object of class C. C# first looks at class B. Here X is new and virtual both, which makes it a unique method X. Sadly, the X in C has the override modifier which sees to it that the X of C hides the X of B. This calls the X of C instead. If we remove the override modifier from X in class C, the default will be new, that cuts off the relation from the X of B. Thus, as it is, a new method, the X of B gets invoked.

A virtual method cannot be marked by the modifiers static, abstract or override. A non virtual method is said to be invariant. This means that the same method gets called always, irrespective of whether one exists in the base class or derived class. In a virtual method, the run-time type of the object decides on which method to be called and not the compile-time type as is in the case of non virtual methods. For a virtual method, there exists a most derived implementation which always gets called.

9. Runtime Polymorphism with Four Classes

OK! We did a lot of coding. How about if I tell you that we are going to add one more class to our code, yes that is class ClassD. So we go more deep into the concept of Polymorphism and Inheritance.

We add one more class to the three classes solution on which we were working on (remember?). So our new class is named ClassD.

Output

ClassB XXX
ClassB XXX
ClassD XXX
ClassD XXX

Explanation

One last explanation of virtual and override will be a bit complex.

The first output, ClassB XXX, is the outcome of the statement a.XXX();. We have the method XXX marked virtual in class ClassA. Therefore, when using new keyword, we now proceed to class ClassB and not ClassD as explained earlier. Here, XXX has an override and since C# knows that class ClassC inherits this function XXX. In the class ClassC, since it is marked as new, C# will now go back and not proceed further to class ClassD. Finally the method XXX gets called from class ClassB as shown in the output above.

If we change the method XXX in class ClassC to override, then C# will proceed to class ClassD and call the XXX of class ClassD as it overrides the XXX of ClassC.

Remove the override from XXX in class ClassD and the method will get invoked from class ClassC as the default is new.

When we talk about object b, everything seems similar to object a, as it overrides the XXX of class ClassA.

When we restore back the defaults, let’s have a look at the third line. Object c here looks like ClassC. In class ClassC, XXX() is new and therefore it has no connection with the earlier XXX methods. In class ClassD, we actually override the XXX of class ClassC and so the XXX of ClassD gets invoked. Just remove the override and then it will get invoked from class ClassC. The object d does not follow any of the above protocols as both the sides of the equal sign are of same data types.

Point to remember: An override method is a method that has the override modifier included on it. This introduces a new implementation of a method. We can’t use the modifiers such as new, static or virtual along with override. But abstract is permitted.

Output

ClassA XXX
ClassB XXX
ClassA XXX
ClassB XXX
ClassC XXX

When we use the reserved keyword base, we can access the base class methods. Here no matter XXX is virtual or not, it will be treated as non virtual by the keyword base. Thus the base class XXX will always be called. The object a already knows that XXX is virtual. When it reaches ClassB, it sees base.XXX() and hence it calls the XXX method of ClassA. But in the second case, it first goes to class ClassC, here it calls the base.XXX, i.e., the method XXX of class ClassB, which in return invokes method XXX of class ClassA.

Output

Error: {Cannot evaluate expression because the current thread is in a stack overflow state.}

In this kind of case, no casting will stop the infinite loop. Therefore even though this is being cast to a class ClassA, it will always call XXX from class ClassB and not ClassA. So we get no output.

11. Summary

Let’s summarize all the points to remember we got in the big article.

In C#, We can equate an object of a base class to a derived class but not vice versa.

The override modifier is needed as the derived class methods will get first priority and be called upon.

These modifiers like new and override can only be used if the method in the base class is a virtual method. Virtual means that the base class is granting us permission to invoke the method from the derived class and not the base class. But, we have to add the modifier override if our derived class method has to be called.

If the base class object declared the method virtual and the derived class used the modifier override, the derived class method will get called. Otherwise, the base class method will get executed. Therefore for virtual methods, the data type created is decided at run time only.

All the methods not marked with virtual are non virtual, and the method to be called is decided at compile time, depending upon the static data type of the object.

An override method is a method that has the override modifier included on it. This introduces a new implementation of a method. We can’t use the modifiers such as new, static or virtual along with override. But abstract is permitted.

12. Conclusion

Long article, my readers advice me to write short articles, but I can’t help myself. I write in a flow until and unless I clear the whole concept I do not wish to stop. My purpose is to share each and every detail in an easy manner, so that you start loving OOP. However in this article, I have tried to categorize the sections under different headings for the sake of readability.

In this article, we learnt the concept of run time polymorphism and inheritance. We covered most of the scenarios by doing hands-on lab. We’ll be covering more topics in my upcoming articles. Feel free to write comments or queries. Do like my article and rate if it helped you by any means, that will make me happy. Happy coding.

Share

About the Author

I am a Microsoft MVP, C# Corner MVP,a Code project MVP,blogger,programmer by heart and currently working as a Sr. Analyst in Magic Software and have an experience of more than 8 years in C#.Net. I am a B.Tech in Computer Science and hold a diploma in Information Security and Application Development. My work experience includes Development of Enterprise Applications using C#,.Net and Sql Server,Analysis as well as Research and Development. I am a MCP in Web Applications(MCTS-70-528,MCTS-70-515) and .Net Framework 2.0 (MCTS-70-536). Visit my personal blog CodeTeddy for more informative articles.____________________________________________________________________________________________________Article of Day http://www.asp.net/community/articles on 04 April 2016.Article of Day http://www.asp.net/community/articles on 26 March 2016.Article of Day http://www.asp.net/community/articles on 29 Jan 2016.Article of Day http://www.asp.net/community/articles on 01 Aug 2015.Article of Day http://www.asp.net/community/articles on 28 July 2015.Article of Day http://www.asp.net/community/articles on 28 June 2015.Article of Day http://www.asp.net/community/articles on 08 June 2015.Article of Day http://www.asp.net/community/articles on 02 June 2015.Article of Day http://www.asp.net/community/articles on 01 June 2015.Article of Day http://www.asp.net/community/articles on 19 July 2014.Article of Day http://www.asp.net/community/articles on 21 May 2014.Article of Day http://www.asp.net/community/articles on 29 Oct 2013.Article of Day http://www.asp.net/community/articles on 29 Sept 2013.Article of Day http://www.asp.net/community/articles on 08 Sept 2013.Article of Day http://www.asp.net/community/articles on 28 Aug 2013.Article of Day http://www.asp.net/community/articles on 16 Aug 2013.Winner http://www.c-sharpcorner.com/News/3067/july-2013-month-winners-announc

Wouldn't it be better if you use Manager, Employee and Person or something meaningful as class name in all your example? It would be more intuitive and easier to follow. All the example form the article are class A, B or C, and you don't even specify these classes in sequence as they are doing inheritance. It's is very confusing to the me and hard to follow alone. Other than that, I think article does a good job explaining concept, appreciate you take the time writing these series, would be great to give more consideration on better class names.

Concerning this segment, I have italicized what I believe is a typo:y.BBB also does the same thing, but the method now is defined virtual in class ClassB. Thus C# looks at the class ClassB, the one it was initialized to. Here BBB is marked with the modifier “new”.

I believe the phrase you want here is "Thus C# looks at the class ClassA..."

It would be great if you can explain how exactly compiler treats the code when we create reference of class which has new keyword and the one which has override keyword. i think if a person understands that he will able to answer any scenario with any permutations and combinations of new and override.

My doubt is, as you have mentioned in section 7 to change the "new" keyword to "override" keyword. The base class of ClassC is ClassA also have Override keyword, does override keyword and virtual acts same.

I can lear a lot from your articles and not just me. I vote 4, considering 5. But as you said, you are writing long articles. In this situation can you considered using more different returns from method? Not something Like 'B AAA', 'B BBB', 'A CCC'. It is real maze and Man, I get a headache! (:

Is the new and virtual keyword (and whole concept about those keywords) in this article can be applied to all languages? Btw, nice article as usual. I love how you explained these concepts. 5 out of 5 !

"These modifiers like new and override can only be used if the method in the base class is a virtual method."

Actually, the new keyword is used to hide a base method instead of trying to override it. It can hide virtual and non-virtual methods and, in fact, it is more commonly used to change the return type of a non-virtual method to a more specific one, as it is impossible to change the return type to a more specific one and keep the method virtual (at least in C#). In that particular case it is possible that the method/property is sealed to create another one with the more specific return type.

you should have to update and fix the document... I have just printed the pdf (really a good work) but the error is still in it. a fix could be " modifier "NEW" can be used with virtual and not virtual method instead of "OVERRIDE" that can be used only for virtual methods"

Aside from a small error in section 5, I think everything in this article is "correct", yet I think that the chosen names are terrible. Why class A inherit from B and not the opposite? In fact, it becomes even stranger as class C inherits from A. So, if we continue going on, class D will inherit from C, class E will inherit from D etc... so, why class A and B are in the inverse order?Why use names like A, B, C, AAA, BBB, CCC? Why not put meaningful names to things to make things clear?

At first it was confusing for me too but actually it helps me later .For example B for base and I get more practice by using these confusing names. It helped me to remember the concepts even in confusing names.