This is a simplified example to explain my issue - I am trying to improve the code readability for an explicitely implemented generic interface by deriving the generic interface to an interface with a concrete type like this: `interface ITyped : IGeneric<string>`. The idea is to not have to use `IGeneric<string>` in all the implemented explicit method names.

So the code would read:

```
ITyped.M1(string p){}
ITyped.M2(string p){} 

```

instead of 

```
IGeneric<string>.M1(string p){}
IGeneric<string>.M2(string q){}

```

Imagine an interface with multiple generic types to understand why I'm trying this.

Now the thing is: this won't work! The compiler throws an Error that my declaration is not a member of the interface. I have to explicitely use the base interface with the generic declaration. Wouldn't it make sense if this worked? Further tries revealed that not even generics are required - a simple derived interface also doesn't allow to explicitely implement an inherited method of the base interface in the derived interface. I'd like to understand the theory why it wasn't allowed.

Is there an alternative to improve the readability for this scenario?

Complete example code here:

```
interface IGeneric<T>
{
    void M(T t);
}

interface ITyped: IGeneric<string> { }

class C : ITyped
{
    //Explicit declaration with base interface - OK
    void IGeneric<string>.M(string t) {}

    //Implicit declaration - OK
    public void M(string t){ }

    //Explicit declaration with derived interface - Error!
    void ITyped.M(string t) {} //Error CS0539   

}

```