对实现通用接口的抽象类执行“保护的抽象替代”

Question

I have an interface which looks like this:

public interface ISomeInterface<out TEntityA, TEntityB> 
    where TEntityA : ISomeEntityA
    where TEntityB : ISomeEntityB
{
    TEntityA SomeMethod(TEntityB entityB);
}  

On the other hand, I have a abstract class which implements this interface, so, using the intellisense the implementation looks this way:

public abstract class BaseAbstractClass : ISomeInterface<EntityA, EntityB>
{
    public EntityA SomeMethod(EntityB entityB)
    {
        throw new NotImplementedException();
    }
}

Since EntityA and EntityB are both concrete implementations of ISomeEntityA and ISomeEntityB respectively, it seems that I'm forced to throw a NotImplementedException and this looks pretty dirty.

Being that you can't change the signature when you override a method, my question is: "Is there a way to perform a 'protected abstract override' in order to force the implementation of SomeMethod in the inherited classes of BaseAbstractClass ?"

For more clarity, I want to do is something like this (It won't compile) :

public abstract class BaseAbstractClass : ISomeInterface<EntityA, EntityB>
{
    public abstract override EntityA SomeMethod(EntityB entityB);
}

Answer 1

Why don't you call it something else?

public abstract class BaseAbstractClass : ISomeInterface<EntityA, EntityB>
{
    protected abstract EntityA SomeMethodImpl(EntityB entityB);

    public EntityA SomeMethod(EntityB entityB) 
    {
        return SomeMethodImpl(entityB);
    }
}

Answer 2

Simply get rid of the override . This will compile:

public abstract class BaseAbstractClass : ISomeInterface<EntityA, EntityB>
{
    public abstract EntityA SomeMethod(EntityB entityB);
}

It's called an "abstract interface implementation".