C＃多个抽象类组合设计


C# Multiple abstract class composition design

本问题已经有最佳答案，请猛点这里访问。

我在MonoGame中准备了一个小游戏引擎，在这里我希望有类似于由DrawableObject和ClickHandler组成的游戏对象(即：

1
public class GameObject : DrawableObject, ClickHandler

问题是-c不支持多重继承，我需要使用接口。我已经创建了drawableobject和clickhandler抽象类，因此它们可以具有一些已经实现的功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public abstract class ClickHandler
{
    public class NullClick : ClickHandler
    {
        public override void Click(Point mousePos)
        {
            Debug.Print("Clicked on:" + mousePos +". NullClickHandler assigned");
        }
    }
    private readonly byte _handlerId;

    public static readonly NullClick NullClickHandler = new NullClick();
    private ClickHandler() {}
    public ClickHandler(ref ClickMap clickMap)
    {
        _handlerId = clickMap.registerNewClickHandler(this);
    }

    public abstract void Click(Point mousePos);

    void unregisterHandler(ref ClickMap clickMap)
    {
        clickMap.releaseHandler(_handlerId);
    }
}

class DrawableObject
{
    Texture2D texture;
    public Rectangle position;

    public DrawableObject()
    {
        position = Rectangle.Empty;
    }

    void Load(ref GraphicsDevice graphics)
    {
        using (var stream = TitleContainer.OpenStream("Content/placeholder.jpg"))
        {
            texture = Texture2D.FromStream(graphics, stream);
            position.Width = texture.Width;
            position.Height = texture.Height;
        }
    }
    void Draw(){} //here is going to be some default implementation
}

号

有什么建议我如何重新设计这个来实现它吗？我不想把整个实现转移到每个类中，在这些类中我将这个作为接口派生。

有一个关于代码项目的解决方案：C的模拟多重继承模式#

下面是最有趣部分的一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
class Aaux : A
{
    C CPart;

    m1();

    static implicit operator C(Aaux a)
    {
        return a.CPart;
    }
}

class Baux : B
{
    C CPart;

    m2();

    static implicit operator C(Baux b)
    {
        return b.CPart;
    }
}

class C
{
    Aaux APart;
    Baux BPart;

    m1()
    {
        APart.m1();
    }
    m2()
    {
        BPart.m2();
    }

    static implicit operator A(C c)
    {
        return c.APart;
    }
    static implicit operator B(C c)
    {
        return c.BPart;
    }
}
相关讨论