C# is an Object-oriented programming language. C# comes with simplicity, expressiveness and great performance to meet the programmer productivity.
Introduction
So far, we have discussed with
abstract, sealed and override modifiers (keywords) in C#. Now, let's study some other modifiers with examples in this chapter.
Objective
The main objective of this article is to learn
virtual,
const and
event modifiers in
C# programming language.
virtual
Virtual is a
C# keyword which is used to modify a type and allows that type to get overridden in the derived classes. In other words, a virtual method can be overridden by any derived classes which means it is a method that can be redefined.
Syntax,
class Base
{
protected virtual void Test() // Virtual method
{
..............;
}
}
class Derived : Base
{
protected override void Test() // overridden method from Base class
{
..............;
}
}Now, in the above syntax we have two classes
Base and
Derived (Which inherits
Base). We have called the virtual methods of the Base class in the Derived class by using
override keyword.
Let's have a look at the clear example below,
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Man
{
class Base
{
public virtual void Test1() // virtual method with public access
{
Console.WriteLine("Test1 method in Base class");
}
protected virtual void Test2() // virtual method with protected access
{
Console.WriteLine("Test2 method in Base class");
}
}
class Derived : Base
{
public override void Test1() // overridden method from the Base class
{
Console.WriteLine("Test1 method in Derived class");
}
protected override void Test2() // overridden method from the Base class
{
Console.WriteLine("Test2 method in Derived class");
}
}
class Program
{
static void Main()
{
Base b1 = new Base(); // Both Compile time and Runtime types are same.
b1.Test1();
// b1.Test2(); // This gives compile time error due to its protection level
Base b2 = new Derived(); // Runtime is Derived....
b2.Test1();
// b2.Test2(); // This gives compile time error due to its protection level
}
}
}Note: Please read comments in the code.
In the above code, we have the
Base and
Derived classes with
virtual and
override modifiers. Based on the access level (public, private, protected etc.), methods are being called in the above code.
Now press Ctrl + F5 and see the result in your console something like,
const
const is used to declare a constant which may be a local variable or a field. It means, the types declared with const cannot be modified.
- In C#, constants we go for can be numeric types, values, strings, null reference or
boolean. - const keyword restricts a field to get modified at the program runtime. Any further modifications should be done in the compile time only.
- const values are inserted into the program at the compile time.
- Look up overhead is also eliminated with const keyword.
Example code,
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Man
{
class Program
{
const string Name = "Krishna"; // Declaration of constant field
static void Main()
{
Console.WriteLine("Name: " + Name);
// Name = "Vamshi"; // Modification is not allowed and gives you compile time error.s
const int Num = 1; // Declaration of constant local variable
// Num = 2; // Enabling this will gives you the compile time error
Console.WriteLine("No: " + Num);
}
}
}Note: Please read comments in the code.
If you observe the above code clearly, you will come to know that we cannot modify a const value (which gives compile time error).
The above code results the below output,
event
In order to declare any event, event modifier is used. It can have many handlers. In some cases, we need to have a notification system. This can be achieved by using event handlers. We can implement further methods easily without affecting the remaining code.
Let's have an example of creating event menu like below,
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
public delegate void Handler(); // Specifying the type
namespace Man
{
class Program
{
public static event Handler menu; // Declaration of event
static void Main()
{
menu += new Handler(Birthdays); // Adding Birthdays to menu event
menu += new Handler(Meetings); // Adding Meetings to menu event
menu += new Handler(Reminders); // Adding Reminders to menu event
menu.Invoke(); // Invoking the event
}
static void Birthdays()
{
Console.WriteLine("Today is Krishna's 24th birthday");
}
static void Meetings()
{
Console.WriteLine("Today's Meetings.....");
}
static void Reminders()
{
Console.WriteLine("Remind to do ......");
}
}
}In the above code, we have an
event '
menu' in which we are adding
Birthdays,
Reminders and
Meetings.
event stores all the methods that we have created to its event list.
We have used delegate keyword to specify the type Handler.
'+=' is used to invoke all the methods at the same time. If you remove '+' in the above code, only Reminders will be invoked.
Note: Please read comments in the code.
The above code will gives you the following output in your console,
Conclusion
In this article, we have learnt
virtual,
const and
event modifiers (keywords) with examples. Hope you understand them.
Thanks for reading,
Regards,
Krishna.