interface in c#

siddharth rai

"The CLR requires that interface methods be marked as virtual. If you do not explicitly mark the method as virtual in your source code, the compiler marks the method as virtual and sealed; this prevents a derived class from overriding the interface method. If you explicitly mark the method as virtual, the compiler marks the method as virtual (and leaves it unsealed); this allows a derived class to override the interface method. If an interface method is sealed, a derived class cannot override the method. However, a derived class can re-inherit the same interface and can provide its own implementation for the interface’s methods."

please i need explanation of some point which is underline in above paragraph .

if we can not declare interface method as virtual then what is the meaning of these line "If you explicitly mark the method as virtual, the compiler marks the method as virtual (and leaves it unsealed); this allows a derived class to override the interface method"

2 Replies

Know the answer? Post it — somebody with the same question will find it here.

siddharth rai12y ago
really very very thanking you sir .
Vulpes12y ago
I think that quotation is describing what happens at the CIL level.

For example, if you have this C# program:

using System;

interface IFace
{
void MyMethod();
}

class MyClass : IFace
{
public void MyMethod()
{
Console.WriteLine("MyMethod called");
}
}

class MyDerivedClass : MyClass
{

}

class Program
{
static void Main()
{
IFace mc = new MyClass();
mc.MyMethod();
IFace mdc = new MyDerivedClass();
mdc.MyMethod();
Console.ReadKey();
}
}

and you look at the CIL which the C# compiler generates, you'll see the following code for MyClass.MyMethod:

.method public hidebysig newslot virtual final instance void MyMethod() cil managed
{
// blah
}

So, as you can see, MyMethod has been marked as virtual and final (CIL's word for 'sealed').

The output of this program is:

MyMethod called
MyMethod called

If you now change the C# declaration to:

public virtual void MyMethod()
{
Console.WriteLine("MyMethod called");
}

the generated CIL becomes:

.method public hidebysig newslot virtual instance void MyMethod() cil managed
{
// blah
}

So the method is still marked as virtual but is no longer final.

If we now add an override of MyMethod to MyDerivedClass:

class MyDerivedClass : MyClass
{
public override void MyMethod()
{
Console.WriteLine("MyDerivedClass's MyMethod called");
}
}

and run the program the output is:

MyMethod called
MyDerivedClass's MyMethod called

If you don't mark MyClass.MyMethod as virtual, then MyDerivedClass needs to reimplement the IFace interface to provide its own implementation:

class MyDerivedClass : MyClass, IFace
{
new public void MyMethod()
{
Console.WriteLine("MyDerivedClass's MyMethod called");
}
}

The output is still then:

MyMethod called
MyDerivedClass's MyMethod called

So I think you need to be careful here to distinguish C# code from the generated CIL code.

The main point here is that, when a C# class implements an interface method, it is implicitly virtual and also sealed as well.