多个显式接口实现

Question

I have the following base interface

public interface IBaseAction
{
   bool CanAct(...)
}

and two inheriting interface say

public interface IAction1 : IBaseAction{}

and

public interface IAction2 : IBaseAction{}

My problem is, I have a class which implements both, and I want to implement CanAct DIFFERENTLY.

public class ComplexAction : IAction1, IAction2
{
   bool IAction1.CanAct(...){} //doesn't compile as CanAct is not a member of IAction1!!
}

ComplexAction c=new ComplexAction();
var a1 = (IAction1)c;
var a2 = (IAction2)c;
a1.CanSave(); //THESE TWO CALLS SHOULD BE IMPLEMENTED DIFFERENTLY
a2.CanSave();

Is there a reasonably clean way to do this?
(Also, my interfaces have semantic meaning and at least three more functions, so it is out of the question to throw out the whole hierarchy, but I'd be willing to copy bool CanAct to every inheriting interface if that is the only solution (there are 4-6 of them))

Answer 1

And what the CLR is supposed to do if someone calls ((IBaseAction)a1).CanSave() ? There could be just one implementation for IBaseAction.CanSave() . So I think you can't do this conceptually.

This is a fundamental problem of multiple inheritance called the diamond problem . The bottom line is: if you hit it, your type hierarchy design is definitely wrong. Eg in this particular case, you're better off with the Role class model (also known as the Role pattern).

Answer 2

You can't do what you describe. Just imagine what would happen if a client requests the IBaseAction interface. Which one should be returned?

It sounds to me like each action should be implemented by separate objects.

Answer 3

You're trying to implement diamond inheritance with Interfaces. The whole reason you're not allowed to implement multiple classes in the first place is to avoid diamond inheritance.

If you want to combine two interfaces together as a ComplexAction , you'd do something like the following:

interface IAct
{
    bool CanAct();
}

class Act1 : IAct
{
    public bool CanAct()
    {
        return true;
    }
}

class Act2 : IAct
{
    public bool CanAct()
    {
        return false;
    }
}

class ComplexAction : IAct
{
    private Act1 action1;
    private Act2 action2;

    public ComplexAction(Act1 action1, Act2 action2)
    {
        this.action1 = action1;
        this.action2 = action2;
    }

    public bool CanAct()
    {
        return action1.CanAct() && action2.CanAct();
    }
}

A ComplexAction is a composition of different IAct s. If you're appending a number to an Interface name, chances are high that you're doing something wrong.

If instead, you want to define different behaviour based on the Interface, that Interface must have it's method defined on itself.

interface IAct1
{
    bool CanAct();
}

interface IAct2
{
    bool CanAct();
}

class SometimesAct1SometimesAct2 : IAct, IAct1, IAct2
{
    bool IAct1.CanAct()
    {
        return false;
    }

    bool IAct2.CanAct()
    {
        return true;
    }

    public bool CanAct()
    {
        Console.WriteLine("Called on IAct or SometimesAct1SometimesAct2");
        return false;
    }
}

To avoid the problems of diamond inheritance, you must give an implementation for ALL interfaces that define a particular method, so there is no ambiguity.

Answer 4

I think you're trying to use inheritance for something it was not meant to do. If you have a complex action, it's composed of simpler actions, it's not multiple different actions at the same time.

Your ComplexAction should have properties Action1 and Action2 , of types IAction1 and IAction2 that have properly implemented CanSave() .

Answer 5

It's not defined by IAction1 but by IBaseAction .

The solution is to not let complex action implement both (your current solution might be breaking SRP)

Answer 6

You do need to re-declare the members of IBaseAction on the interfaces that need to defer, but then you also need to implement IBaseAction 's members implicitly or explicitly if there are no implicit implementations of the members (to make sure all interfaces are satisfied).

interface IBase {
    void Act();
}

interface IAction1 : IBase {
    void Act();
}

interface IAction2 : IBase {
    void Act();
}

class MyClass : IAction1, IAction2 {
    public void Act() {
        Console.WriteLine( "satisfies IBase.Act()" );
    }
    void IAction1.Act() {
        Console.WriteLine( "IAction1.Act()" );
    }
    void IAction2.Act() {
        Console.WriteLine( "IAction2.Act()" );
    }

    static void Main( string[] args ) {
        MyClass cls = new MyClass();
        cls.Act();
        IAction1 a = cls;
        a.Act();
        IAction2 b = cls;
        b.Act();
        Console.ReadKey();
    }
}

It may be redundant to point out that this design is strange to have overlapping-named members that force you into jumping through hoops like this, but I figured I'd note it anyway.

You did say you can't toss your current hierarchy, but it might be possible to refactor it to avoid these shenanigans.

Answer 7

This wont work. You are assuming that IAction1 inherits IBaseAction, but that is not the case. Interfaces cannot inherit other interfaces. You can check this out by using reflection to see the baseclass of IAction1. It will not be IActionBase.

What you are saying with your code is: when a class implements IAction1 then it is also required to implement IBaseAction. C# will then help you by assuming you are implementing IActionBase by just telling it you implement IAction1. Also when using a var of type IAction1 you can call members from IBaseAction becouse it knows it is implemented.