Question

我有许多接口，如下所示：

public interface IFoo
{
    void FooAction();
}

public interface IBar
{
    void BarAction();
}

public interface IBiz
{
    void BizAction();
}

...others...

我还为我的接口定义了一个基本的抽象实现。像这样：

public abstract class BaseFoo() : IFoo
{
    void FooAction() { ... }
}

public abstract class BaseBar() : IBar
{
    void BarAction() { ... }
}

public abstract class BaseBiz() : IBiz
{
    void BizAction() { ... }
}

... others

现在我需要另外一些实现这些接口子集的类。例如：

public class FooBar : IFoo, IBar
{
    ....
}

public class FooBiz : IFoo, IBiz
{
    ....
}

public class FooBarBiz : IFoo, IBar, IBiz
{
    ....
}

在支持多继承的语言中，我将实现从多个抽象类继承的上述类：例如：

public class FooBar : BaseFoo, BaseBar, IFoo, IBar
{
    ....
}

public class FooBiz : BaseFoo, BaseBiz IFoo, IBiz
{
    ....
}

public class FooBarBiz : BaseFoo, BaseBar, BaseBiz, IFoo, IBar, IBiz
{
    ....
}

但是在C＃中不允许这样做，因为不支持这种继承。

为了达到相同的结果，我认为这里的方法是使用组合而不是继承，并按以下方式定义类：

public class FooBar : IFoo, IBar
{
    private readonly BaseFoo Foo { get; set; } // not abstract now
    private readonly BaseBar bar { get; set; } // not abstract now

    FooBar(IFoo foo, IBar bar) // Dependency injected here
    {
        Foo = foo;
        Bar = bar;
    }

    void FooAction()
    {
        Foo.FooAction();
    }

    void BarAction()
    {
        Bar.BarAction();
    }
}

首先：这种模式是否正确？让我觉得这里有些气味的东西是继承的组合隐藏了受保护的属性和基类的字段。

我还可以为每个接口排列提供基本抽象类，而不是组合。例如。定义一个BaseFooBar，BaseFooBiz，BaseFooBarBiz，但在这种情况下，我发现有太多的工作和重复的代码。

这种问题的正确方法是什么？

合成超过继承限制

0 个答案: