Method Hiding

Let's understand it with an example.
In Visual Studio, I have created a console application in which there is a class named “Student” that has the two fields FirstName and LastName and a method that prints the FirstName and LastName on the console screen.

1. using System;  
2.   
3. namespace methodHidingInCSharp {  
4.     class Student {  
5.         public string FirstName;  
6.         public string LastName;  
7.         public void PrintName() {  
8.             Console.WriteLine(FirstName + " " + LastName);  
9.         }  
10.     }  
11.     class Program {  
12.         static void Main(string[] args) {  
13.   
14.         }  
15.     }  
16. }  

Now let's go and create a DiplomaStudent and GraduateStudent class that inherits from the Student class.

1. using System;  
2.   
3. namespace methodHidingInCSharp {  
4.     class Student {  
5.         public string FirstName;  
6.         public string LastName;  
7.         public void PrintName() {  
8.             Console.WriteLine(FirstName + " " + LastName);  
9.         }  
10.     }  
11.   
12.     class DiplomaStudent : Student {  
13.   
14.     }  
15.   
16.     class GraduateStudent : Student {  
17.           
18.     }  
19.   
20.     class Program {  
21.         static void Main(string[] args) {  
22.   
23.         }  
24.     }  
25. }  

If I need to create an object of DiplomaStudent and GraduateStudent, I can do it in our Main method as in the following:

1. class Program {  
2.     static void Main(string[] args) {  
3.         DiplomaStudent ds = new DiplomaStudent();  
4.         ds.FirstName = "Sam";  
5.         ds.LastName = "Fisher";  
6.         ds.PrintName();  
7.   
8.         GraduateStudent gs = new GraduateStudent();  
9.         gs.FirstName = "Aiden";  
10.         gs.LastName = "Pearce";  
11.         gs.PrintName();  
12.     }  
13. }  

Note
Since we are inheriting the Diploma and Graduate Student classes from the Student class, all the members except the private members can be called.

If we run the project, we will get the output as:



So, we have the output we are expecting. But there is a slight problem. We don't know out of these two which one is the diplomaStudent and which one is the graduateStudent and to overcome this problem I can add a (– studentType) appended to his name stating diploma or graduate student. With which by just looking at the names we can determine which one is a diploma student and which one is the graduate student.

Let's flip back to our project. Now what I will do is to create a PrintName method that is the same in both of the derived classes and I will append a diploma student and a graduate student to make it more readable and clear.

1. class DiplomaStudent : Student {  
2.     public void PrintName() {  
3.         Console.WriteLine(FirstName + " " + LastName + " - Diploma Student");  
4.     }  
5. }  
6.   
7. class GraduateStudent : Student {  
8.     public void PrintName() {  
9.         Console.WriteLine(FirstName + " " + LastName+ " - Graduate Student");  
10.     }  
11. }  

And as we know we have the same method in our base class too.

1. class Student {  
2.     public string FirstName;  
3.     public string LastName;  
4.     public void PrintName() {  
5.         Console.WriteLine(FirstName + " " + LastName);  
6.     }  
7. }  

So, what our child class will do is to hide the base class Implementation.

But when we build our solution, we see a Green squiggly line and if we hover the mouse on it, it indicates that if you where intentionally hiding the inherited member then use the new keyword.



To hide an inherited member from the derived class, use the new keyword as in the following:

1. class DiplomaStudent : Student {  
2.     public new void PrintName() {  
3.         Console.WriteLine(FirstName + " " + LastName + " - Diploma Student");  
4.     }  
5. }  
6.   
7. class GraduateStudent : Student {  
8.     public new void PrintName() {  
9.         Console.WriteLine(FirstName + " " + LastName+ " - Graduate Student");  
10.     }  
11. }  

Run the program:



So, we have accomplished what we wanted. Now let's see how to invoke it back after hiding it.

We can do it in three ways.

The first one is to use the base keyword.

1. class DiplomaStudent : Student {  
2.       public new void PrintName() {  
3.           base.PrintName();  
4.       }  
5.   }  
6.   
7.   
8.   class GraduateStudent : Student {  
9.       public new void PrintName() {  
10.           Console.WriteLine(FirstName + " " + LastName+ " - Graduate Student");  
11.       }  

So, if I go and run this now I will get the base class implementation.



The second way to do this is to type-caste the child class variable to the base class.

1. using System;  
2.   
3. namespace methodHidingInCSharp {  
4.   
5.     class DiplomaStudent : Student {  
6.         public new void PrintName() {  
7.             Console.WriteLine(FirstName + " " + LastName + " - Diploma Student");  
8.         }  
9.     }  
10.   
11.     class GraduateStudent : Student {  
12.         public new void PrintName() {  
13.             Console.WriteLine(FirstName + " " + LastName+ " - Graduate Student");  
14.         }  
15.     }  

In the preceding two classes I have provided the derived class method implementation and used the new keyword to hide the base method implementation. That means that when we run the application, it will print the child class implementation.

1. class Program {  
2.     static void Main(string[] args) {  
3.         DiplomaStudent ds = new DiplomaStudent();  
4.         ds.FirstName = "Sam";  
5.         ds.LastName = "Fisher";  
6. re I have type-casted the child class reference variable into a base class  
7.         ((Student)ds).PrintName();  
8.   
9.         GraduateStudent gs = new GraduateStudent();  
10.         gs.FirstName = "Aiden";  
11.         gs.LastName = "Pearce";  
12.         ((Student)gs).PrintName();  
13.     }  
14. }  

Run the program.



In the preceding output, we have the base implementation.

The third way is to create a base class reference variable pointing to the child class.

1. class Program {  
2.     static void Main(string[] args) {  
3.         Student ds = new DiplomaStudent();  
4.         ds.FirstName = "Sam";  
5.         ds.LastName = "Fisher";  
6.         ds.PrintName();  
7.   
8.         Student gs = new GraduateStudent();  
9.         gs.FirstName = "Aiden";  
10.         gs.LastName = "Pearce";  
11.         gs.PrintName();  
12.     }  
13. }  

The output remains the same.