Question

Firstly I am pretty new to C#. I would like to have an interface declare a member function like in the following piece of code

interface IMyInterface {
    void MyAction() {
        // do stuff depending on the output of function()
    }
    void Function();
}

here Function is pure virtual and should be implemented by children of IMyInterface. I could use an abstract class instead of an interface but then I could not inherit from other classes… Say for example that MyAction is recursiverly searching a directory for files and applying Function to any file found to make my example clear.

How to change my design in order to overcome the constraint that interfaces cannot implement classes ?

Edit : In C++ what I would do is using templates as such

template<class A>
static void MyAction(const A& a) {
    // do stuff depending on the output of A::Function()
};

class MyClass {
    void Function();
};

I was wondering if there were an elegant way to do this using interfaces in C#.

Answer 1

In C# you don’t have multiple inheritance. You can circumvent this limitation by using composition.

Define your interface like this (Function needs not to be defined here):

public interface IMyInterface
{
    void MyAction();
}

Declare an abstract class with an abstract Function and implementing this interface:

public abstract class MyInterfaceBase : IMyInterface
{
    public void MyAction()
    {
        // Do stuff depending on the output of Function().
        Function();
    }

    protected abstract void Function();
}

From this abstract class you can derive a concrete implementation. This is not yet your “final” class, but it will be used to compose it.

public class ConcreteMyInterface : MyInterfaceBase
{
    protected override void Function()
    {
        Console.WriteLine("hello");
    }
}

Now let’s come to your “final”, composed class. It will derive from SomeBaseClass and implement IMyInterface by integrating the functionality of ConcreteMyInterface:

public class SomeBaseClass
{
}

public class MyComposedClass : SomeBaseClass, IMyInterface
{
    private readonly IMyInterface _myInterface = new ConcreteMyInterface();

    public void MyAction()
    {
        _myInterface.MyAction();
    }
}

---

UPDATE

In C# you can declare local classes. This comes even closer to multiple inheritance, as you can derive everything within your composing class.

public class MyComposedClass : SomeBaseClass, IMyInterface
{
    private readonly IMyInterface _myInterface = new ConcreteMyInterface();

    public void MyAction()
    {
        _myInterface.MyAction();
    }

    private class ConcreteMyInterface : MyInterfaceBase
    {
        protected override void Function()
        {
            Console.WriteLine("hello");
        }
    }
}