Multiple inheritance with Abstract class and Interface

While reading about this subject, I found I couldn't easily put it all together in my head, so I wrote the following piece of code, which acts as a cheat-sheet for how C# works. Hope it helps someone.

public interface IMyInterface
{
    void FunctionA();
    void FunctionB();
    void FunctionC();
}

public abstract class MyAbstractClass : IMyInterface
{
    public void FunctionA()
    {
        Console.WriteLine( "FunctionA() implemented in abstract class. Cannot be overridden in concrete class." );
    }

    public virtual void FunctionB()
    {
        Console.WriteLine( "FunctionB() implemented in abstract class. Can be overridden in concrete class." );
    }

    public abstract void FunctionC();
}

public class MyConcreteClass : MyAbstractClass, IMyInterface
{
    public override void FunctionB()
    {
        base.FunctionB();
        Console.WriteLine( "FunctionB() implemented in abstract class but optionally overridden in concrete class." );
    }

    public override void FunctionC()
    {
        Console.WriteLine( "FunctionC() must be implemented in concrete class because abstract class provides no implementation." );
    }
}

class Program
{
    static void Main( string[] args )
    {
        IMyInterface foo = new MyConcreteClass();
        foo.FunctionA();
        foo.FunctionB();
        foo.FunctionC();
        Console.ReadKey();
    }
}

Gives the following output:

FunctionA() implemented in abstract class. Cannot be overridden in concrete class.

FunctionB() implemented in abstract class. Can be overridden in concrete class.

FunctionB() implemented in abstract class but optionally overridden in concrete class.

FunctionC() must be implemented in concrete class because abstract class provides no implementation.

To better understand the concept behind interfaces, I just give you the correct code of your implementation:

public interface IWork{
    void func();
}

public abstract class WorkClass,IWork{
    public void func(){
        Console.WriteLine("Calling Abstract Class Function");
    }
}

public class MyClass:WorkClass{
...
}

The basic rule: You need to include the interface always where the implementation is. So if you create a method within an abstract classes and define an interface of this method, you'll need to implement the interface into your abstract class and then all subclasses will automatically implement this interface.

As a matter of fact, interfaces have 2 kind of functions you can use them for:

1) As a "real" interface providing a generic handling of any class implementing the interface, so you can handle several kind of classes just by one interface (without knowing their real class names). While "handling" means: Calling a method.

2) As a help for other (framework) programmers not to mess up with your code. If you want to be sure that an method won't be replaced with another name, you define an interface for your class containing all "must have" method names. Even if the method is called nowhere, your programmer will get an compile error message when he changed the method name.

Now you can easily handle your Myclass just by the interface IWork.

Because the abstract class implements the interface.

If your class MyClass would not inherit from WorkClass you would get an error saying 'MyClass' does not implement interface member 'IWork.func()'.

But you also inherit from WorkClass, which actually implements the methods that the interface requires.

You can mark func() as abstract if you want to force the classes that inherits from it to implement it like this:

public abstract class WorkClass
{
    public abstract void func();

}

I tried with the classes above in my solution. It inherits the abstract class so the derived class have the func() method definition. This is the reason it was not able to show compiled errors.

func() is not marked as abstract in the WorkClass so you don't need to implement it in any classes that derive from WorkClass.

WorkClass implements the IWork interface so you don't need to implement it in MyClass because it inherits func() from WorkClass.

Since the func method in the abstract class is a non-virtual method, so the compiler thinks this method is a implementation of the interface.

When you extend MyClass to WorkClass, the method func() (which has been defined), is inherited.

So, when the interface IWork is implemented, the method 'func()' has already been defined. So, there are no more undefined methods in MyClass.

So, the class MyClass is a concrete class, due to which you are able to create a MyClass object without any compilation errors.