C# Interface Inheritance to Abstract class

Question

Suppose if I have an Interface as defined below:

public interface IFunctionality
{
    void Method();       
}

and I implement this interface for an abstract class as shown below:

public abstract class AbstractFunctionality: IFunctionality
{
    public void Method()
    {
        Console.WriteLine("Abstract stuff" + "\n");
    }       
}

again I have a concrete class which Inherits from abstract class as below:

public class ConcreteFunctionality: AbstractFunctionality
{
    public void Method()
    {
        Console.WriteLine("Concrete stuff" + "\n");
    }
}

Now I have the following code,

ConcreteFunctionality mostDerived = new ConcreteFunctionality();
AbstractFunctionality baseInst = mostDerived;
IFunctionality interfaceInst = mostDerived;
mostDerived.Method();
baseInst.Method();
interfaceInst.Method();

The output which I am getting after execution of this stuff is as following.

Concrete stuff
Abstract stuff
Abstract stuff

But what I have been expecting the output to be "Concrete Stuff" in all the three cases as what I am doing here is assigning the reference of ConcreteFunctionality to the variables of type AbstractFunctionality and IFunctionality.

What is happening internally. Kindly clarify.

This might clear something up: http://stackoverflow.com/questions/392721/difference-between-shadowing-and-overriding-in-c — Stormenet, Jan 25 '13 at 11:54
"It's hidden, not overridden" -- a good mantra to remember. (But your compiler should have mentioned this; do you have your warnings filtered out?) — kmote, Nov 07 '13 at 20:29

Jon Skeet · Accepted Answer · 2013-01-25T13:08:39.160

Here:

public class ConreteFunctionality:AbstractFunctionality
{
    public void Method()
    {
        Console.WriteLine("Concrete stuff" + "\n");
    }
}

... you're not overriding the existing method. You're creating a new method which hides the existing one. (You should get a warning, too, suggesting the use of the new modifier if you really want this behaviour.) The interface was implemented in AbstractFunctionality, so the interface mapping table refers to the method in that class.

Now if you reimplement the interface:

public class ConcreteFunctionality : AbstractFunctionality, IFunctionality

... then the interface mapping will refer to the method in ConcreteFunctionality and you'll get the behaviour you expect for the call through the interface (i.e. your third call) but you'd still get the implementation in AbstractFunctionality for your second call.

It would be generally cleaner and more sanity-preserving to make the method in AbstractFunctionality virtual, and override it in ConcreteFunctionality. That way it will use the ConcreteFunctionality implementation in all cases.

That wouldn't give the behaviour expected, as the second call would still be through the abstract implementation. — Jon Hanna, Jan 25 '13 at 12:57
@JonHanna: I hadn't noticed the expectation that the second call would *also* use the concrete version. Will edit. — Jon Skeet, Jan 25 '13 at 13:07

mihirj · Answer 2 · 2013-01-25T09:31:01.937

You need to define classes as:

public abstract class AbstractFunctionality:IFunctionality
{
    public virtual void Method()
    {
        Console.WriteLine("Abstract stuff" + "\n");
    }       
}

public class ConreteFunctionality:AbstractFunctionality
{
    public override void Method()
    {
        Console.WriteLine("Concrete stuff" + "\n");
    }
}

As you have not overriden Method() in ConreteFunctionality, the run time environment executes Method() associated with AbstractFunctionality object as it cannot apply dynamic polymorphism here. Introducing virtual and override makes the run time environment to execute the overriden method in child class.

Nice answer; but I would introduce the term "hiding", which describes the OP's original code, and note that hiding a method without the "new" keyword results in a compiler warning. — phoog, Jan 25 '13 at 07:51

score 14 · Answer 3 · edited May 23 '17 at 11:51

14

You are missing virtual and override keywords. Without this you don't get virtual functions.

You can mark Method in AbstractFunctionality as virtual and mark the Method in ConreteFunctionality as override. As mihirj has shown.

Similar issues tackled in - Why are C# interface methods not declared abstract or virtual?

edited May 23 '17 at 11:51

Community

1
1

answered Jan 25 '13 at 07:04

Karthik T

31,456
5
68
87

C# Interface Inheritance to Abstract class

3 Answers3