Some clarification to my comment
Yes, that should indeed just work as intended. An interface defines what methods a class should implement (either directly or throughout the hierarchy).
When you define an interface, you could look at it like this:
An interface's only task is to guarantee that at any the point in a class' hierarchy where the interface is defined in the signature, that class has every method in the interface implemented.
Here's a sample situation that hopefully sheds some light:
void Main() { Z obj1 = new C(); Z obj2 = new B(); Z obj3 = new A(); Y obj4 = new C(); Y obj5 = new D(); Z obj6 = new D(); } interface Y { void someMethod1(); void someMethod2(); } interface Z { void someMethod3(); } class A : Z { public void someMethod3() { } } class B : A { public void someMethod1() { } } class C : B, Y { public void someMethod2() { } } class D : C { } This compiles just fine.
As you can see, B implements Y's method someMethod1 after which C extends B and implements Y. All C does is provide an implementation for someMethod2 and at that point the interface definition is reached: the two methods that are defined in Y are now available to an object of type C.
What's key here is to remember that a class hierarchy are just layers with, amongst others, some methods. At the moment in a hierarchy where you say "this class needs to implement every method defined in <SomeInterface>" you basically have to make sure that each of them is available to your class at that point. Inheritance tells us that we can use the methods of a superclass, which means that by implementing your method in a baseclass you have satisfied the condition.
Sidenote: all of this is written without abstract methods in mind, they're a little different.