C#, provide full support for object-oriented programming including encapsulation,
inheritance, and polymorphism. As a beginners perspective the most confusing concept in C# is the use of
keywords new,override,virtual.These keywords used in c# for achieving polymorphism.
The override modifier extends the
base class method, and the new modifier hides it.
By using new, you are asserting that you are aware that
the member that it modifies hides a member that is inherited from the base
class, the new keyword explicitly hides a member that is inherited from a base
class. When you hide an inherited member, the derived version of the member
replaces the base class version. Although you can hide members without using
the new modifier, you get a compiler warning. If you use new to explicitly hide a member, it
suppresses this warning.
We are going for detailed explanation and usage of new,virtual and override using some examples.
Note : Example programs are in asp.net MVC
Use of new Modifier
namespace TheCodeBehind
{
public class TestingController : Controller
{
public ActionResult
Testing()
{
CodeBehind cb = new
CodeBehind();
string MthodOnedata = cb.Firstmethod();
// will give : One
InheritedOne io = new
InheritedOne();
string MthodTwodata = io.Firstmethod();
//will give : One
return View();
}
}
public class CodeBehind
{
public string Firstmethod()
{
return ("One");
}
}
public class InheritedOne : CodeBehind
{
}
}
In the above code there is no issue, the issue comes when
the derived class contains a function with same name, type and parameters. The below
example describes it.
namespace TheCodeBehind
{
public class TestingController : Controller
{
public ActionResult
Testing()
{
CodeBehind cb = new
CodeBehind();
string MthodOnedata = cb.Firstmethod();
// will give :One
InheritedOne io = new
InheritedOne();
string MthodTwodata = io.Firstmethod();
//it will give : Two
return
View();
}
}
public class CodeBehind
{
public string Firstmethod()
{
return ("One");
}
}
public class InheritedOne : CodeBehind
{
public string Firstmethod()
{
return ("Two");
}
}
}
Here Base class and Derived class have the same function
Firstmethod().Because of inheritance the derived class get all the public,protected,internal and protected internal
members from base class, in above case derived class have two methods with same
type and name. So it will make confusion to the compiler, .net handles this by
hiding the base class function using new modifier in derived class. If we are
not using new modifiers then also .net automatically hides the base class
method and the code will compiled and
executed but it shows a warning likes below.
To avoid this warning we are using the modifier new .it will hide the base class method. The following program explains how to
use new modifier.
namespace TheCodeBehind
{
public class TestingController : Controller
{
public ActionResult
Testing()
{
CodeBehind cb = new
CodeBehind();
string MthodOnedata = cb.Firstmethod();
//One
InheritedOne io = new
InheritedOne();
string MthodTwodata = io.Firstmethod();
//Two
CodeBehind io1 = new
InheritedOne();
string MthodTwodata = io1.Firstmethod();
//One
return View();
}
}
public class CodeBehind
{
public string Firstmethod()
{
return ("One");
}
}
public class InheritedOne : CodeBehind
{
public new string
Firstmethod()
{
return ("Two");
}
}
}
The above program will execute without any
warning.
Use of
virtual and override
Virtual and override modifiers are used for achieving run
time polymorphism in c#
In the above program
CodeBehind io1 = new
InheritedOne();
string MthodTwodata = io1.Firstmethod();
//One
When we create an object for class InheritedOne with type of CodeBehind
And
try to access the method using the object io1 then it will give the base class method .In order to
override this base class method we are using virtual & override
Example:
namespace TheCodeBehind
{
public class TestingController : Controller
{
public ActionResult
Testing()
{
CodeBehind cb = new
CodeBehind();
string MthodOnedata = cb.Firstmethod();// One
Console.WriteLine(MthodOnedata);
InheritedOne io = new
InheritedOne();
string MthodTwodata = io.Firstmethod();//Two
CodeBehind io1 = new
InheritedOne();
string MthodThreedata = io1.Firstmethod();//Two
return View();
}
}
public class CodeBehind
{
public virtual string
Firstmethod()
{
return ("One");
}
}
public class InheritedOne : CodeBehind
{
public override string
Firstmethod()
{
return ("Two");
}
}
}
The above example will override the base class function
and results the derived class when we try to call like below
CodeBehind io1 = new
InheritedOne();
string MthodThreedata = io1.Firstmethod();//Two
Points to remember:
- new modifier is used to achieve compile time polymorphism
- virtual and override are used to achieve run time polymorphism
- We cannot override a non virtual method in c# until the method is not an abstract method.
