Implementing abstract/interface methods containing abstract/interface-type parameters

Question

I have two interfaces:

public interface IController
{
    void doSomething(IEntity thing);
}

public interface IEntity { ... }

One example implementation would be:

public class ControllerImplA : IController
{
    public void doSomething(IEntity entity)
    {
        EntityImplA entityForA = (EntityImplA)entity;
        ...
    }
}

public class EntityImplA : IEntity { ... }

The entity parameter of ControllerImplA.doSomething() will always be EntityImplA. Likewise, the entity parameter of ControllerImplB.doSomething() will always be EntityImplB, and so on so forth for other implementations.

Is there a way to avoid using the downcasting in my current code? In other words, I want to do something like this:

public class ControllerImplA : IController
{
    public void doSomething(EntityImplA entity) { ... }
}

without modifying the interfaces? What about if abstract parent classes are used instead of interfaces?

"Is there a way to avoid using the downcasting" Use generics. "without modifying the interfaces" Uhhh... — BoltClock
– BoltClock, Commented Mar 2, 2017 at 15:51
Is there a reason that you can change your interface to an abstract class but can´t modify the interface itself? — MakePeaceGreatAgain
– MakePeaceGreatAgain, Commented Mar 2, 2017 at 15:54
If you can replace interfaces with abstract class I guess you can modify them also to use generics. — Evk
– Evk, Commented Mar 2, 2017 at 15:55

Baldrick · Accepted Answer · 2017-03-02 16:07:25Z

4

You want to use generics. Modifying the interfaces is the only way to make this clean:

public interface IController<T> where T : IEntity
{
    void doSomething(T thing);
}

Then:

public class ControllerImplA : IController<EntityImplA>
{
    public void doSomething(EntityImplA entity)
    {
        ...
    }
}

However, if you really can't change the interface, e.g. it's provided by a third party library, then the workaround by @dasblinkenlight is about as clean as you're going to get.

edited Mar 2, 2017 at 16:07

answered Mar 2, 2017 at 15:52

Baldrick

11.9k2 gold badges34 silver badges37 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

MakePeaceGreatAgain Over a year ago

"Without modifying the interfaces"...?

Baldrick Over a year ago

Hmm... good point. Didn't see that first time - was it edited in, or did I just miss it? Either way, this is the only way that makes sense.

thegreatjedi Over a year ago

Accepting this. Sorry if it sounds confusing, but when I say I don't want to mess with the interface I meant that I don't really want to modify the method's parameter type to hard-code the specific implementation's type in somehow just to remove the downcasting. I'm fine with changing to abstract class instead of interface...I guess you can say I just don't understand these stuff well enough. Spent like an hour trying to put my question into words too.

Sergey Kalinichenko · Accepted Answer · 2017-03-02 16:00:40Z

3

If you have no control over the interface, implement it in a generic abstract class with a type parameter specifying the entity type, like this:

public interface IController {
    void DoSomething(IEntity thing);
}

public interface IEntity { ... }

abstract class AbstractController<TEntity> : IController where TEntity : IEntity {
    public void DoSomething(IEntity e) {
        // Forward the call to an abstract method with more specific type
        DoSomethingImpl((TEntity)e);
    }
    // Subclasses need to implement this method instead of the interface method:
    protected abstract void DoSomethingImpl(TEntity e);
}

Now your implementations can derive from AbstractController with the specific subclass, like this:

public class ControllerImplA : AbstractController<EntityImplA> {
    public void DoSomethingImpl(EntityImplA entity) { ... }
}

The cast is still there, but now it is shared among all implementations.

answered Mar 2, 2017 at 16:00

Sergey Kalinichenko

729k85 gold badges1.2k silver badges1.6k bronze badges

1 Comment

Baldrick Over a year ago

Good workaround. Kind of like an adaptor from the non-generic interface to a generic abstract class.

MakePeaceGreatAgain · Accepted Answer · 2017-03-02 16:08:34Z

This is the best use-case for generics. To do so add a generic constraint to your interface as Baldrick already mentioned.

If - for whatever strange reason - you don´t want to change the interface, you are stuck on a really ugly solution that hides the casting from your API:

public class ControllerImplA : IController
{
    public void doSomething(IEntity entity)
    {
        this.doSomething((EntityImplA) entity);
    }

    public void doSomething(EntityImplA entity)
    {
        ...
    }
}

This way you can use both methods, the one from the interface which redirects to the other one, and the more derived one defined on your class but not on the interface.

var myIEntity = ...
var myEntity = new EntityImplA();
myControler.doSomething(myIEntity); // calls the interface-method
myControler.doSomething(myEntity);  // direclty calls the class-method

You could also explicitely implement your interface, so that when accessing the method from the interface you see only the more generic method while on the specific class you see only the more concrete implementation.

Collectives™ on Stack Overflow

Implementing abstract/interface methods containing abstract/interface-type parameters

3 Answers 3

3 Comments

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

3 Comments

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related