使用接口的多重继承

Question

请看附图

我想要的是（技术-）“用户”可以通过“HeadClass”的实例使用来自class A、B 或C 的方法。我试图避免的是，我必须为 Class A、B 和 C 中定义的每个方法添加一个单独的函数，以通过“HeadClass”调用它们。昨天我试图在另一个 Whosebug-request 中对此进行描述，但已将其删除，因为它似乎不清楚我想要实现的目标。所以这是另一种方法。

通常这会通过继承来实现（如果只有一个 class 会被继承的话）。但是，正如他们在删除 post 中告诉我的那样，我应该改用界面。现在，到目前为止，我认为我知道接口是如何工作的（几乎每个class都使用），但我不知道我是如何实现这个描述问题的。

我将如何填写“？？？”在“头Class”？我很高兴任何输入。谢谢！

class User
{
    public User(IHeadClass headObj)
    {
        _headObj = headObj
    }

    public DoStuff()
    {
        _headObj.Method_1
        _headObj.Method_2
        _headObj.HeadMethod
    }
    
    
}


public class HeadClass : IHeadClass, ???
{
    ???

    public HeadClass( ??? )
    {
        ???
    }

    void HeadMethod()
    {
        ... do head stuff
    }
}


public class Class_A : IClass_A
{
    public void Method_1 () { }
}


public class Class_B : IClass_B
{
    public void Method_2 () { }     
    public void Method_3 () { }
}

public class Class_C : IClass_C
{
    public void Method_4 () { }
}

我已经查看 this 描述如何使用接口。但这并不能解决上述问题。

Answer 1

如果我没理解错的话，你可以在这里使用合成。像这样：

public interface IClass_A
{
    void Method_1 ();
}

public interface IClass_B
{
    void Method_2 ();
    void Method_3 ();
}

public interface IClass_C
{
    void Method_4 ();
}


public interface IHeadClass : IClass_A, IClass_B, IClass_C
{
    void HeadMethod();
}

public class HeadClass : IHeadClass
{
    private readonly IClass_A _a;
    private readonly IClass_B _b;
    private readonly IClass_C _c;

    public HeadClass(IClass_A a, IClass_B b, IClass_C c)
    {
        _a = a;
        _b = b;
        _c = c;
    }

    void HeadMethod()
    {
        ... do head stuff
    }

    public void Method_1() => _a.Method_1();

    public void Method_2() =>  _b.Method_2();
    public void Method_3() =>  _b.Method_3();

    public void Method_4() => _c.Method_4();
}

Answer 2

C#（不同于 C++ 或 PHP）不支持多重继承。接口允许多重继承，但不提供方法定义，只提供声明。

我认为解决方案可以是称为 fasade 的模式：在 HeadClass 中编写调用其他类中的方法的方法。在这种情况下，接口不是必需的。

public class HeadClass
{
    private Class_A _a;
    private Class_B _b;
    private Class_C _c;

    public HeadClass( Class_A a, Class_B b, Class_C c )
    {
        _a=a;
        _b=b;
        _c=c;
    }

    void HeadMethod()
    {
        ... do head stuff
    }

    public void Method_1 () {
        _a.Method_1();
    }
    public void Method_2 () {
        _b.Method_2();
    }
    public void Method_3 () {
        _b.Method_3();
    }
    public void Method_4 () {
        _c.Method_4();
    }

}

Answer 3

我可以建议您在构造函数中传递一个接口而不是 Class 定义吗？

public class HeadClass
{
    private IMethod1 _method1;
    private IMethod2 _method2;
    private IMethod3 _method3;
    private IMethod4 _method4;

    public HeadClass( IMethod1 method1, IMethod2 method2, IMethod3 method3, IMethod4 method4)
    {
        _method1=method1;
        _method2=method2;
        _method3=method3;
        _method4=method4;
    }

    void HeadMethod()
    {
        ... do head stuff
    }

    public void Method_1 () {
        _method1.Method_1();
    }
    public void Method_2 () {
        IMethod2.Method_2();
    }
    public void Method_3 () {
        IMethod3.Method_3();
    }
    public void Method_4 () {
        IMethod4.Method_4();
    }

}

现在您已经删除了与 class 的任何直接耦合，您不再仅通过接口链接。

假设您想将方法 2 和 3 拆分为它自己的两个 classes？此代码永远不必更改。

您现在可以重用任何具有接口定义的 class 作为参数。没有代码被定义两次，在每个输入中做同样的事情。

因为：

public class Method1 : IMethod1
{

}

public class Method2 : IMethod2
{

}

public class Method3 : IMethod3
{

}

public class Method4 : IMethod4
{

}

can now be parsed as parameters to HeadClass.

or, if you insist method 2 & 3 belong on the same class.

public class ClassA: IMethod1
{

}

public class ClassB: IMethod2, IMethod3
{

}

public class ClassC: IMethod4
{

}

从这个例子中可以明显看出，好处在于您现在可以在 Head 中做任何您想做的事情class，如果您需要改变行为，您可以通过构造函数注入代码，而无需必须重试 headclass.

的行为

而headclass，不知道ClassA、B、C直接存在，只知道接口

我相信这就是所谓的策略模式？

使用接口的多重继承

Multiple inheritance using interaces

c#

interface

multiple-inheritance

abstraction