游戏项的类层次结构建议

你所要求的是合理的,并且 Composite Design Pattern

我觉得你太复杂了。如果mudObjects可以包含其他mudObjects,则需要的单个基类应该沿着这些线:

public abstract class MudObject
{    
    MudObject containedBy; //technically Parent
    List<MudObject> Contains; //children
}

这类似于WinForms和ASP.NET的工作方式。许多容器控件都是控件,并且可以包含子控件的集合。

您想要的是非常合理的:它与Windows窗体控件没有什么不同,Windows窗体控件本身可以是其他控件的容器。

您需要做的是创建自己的 List<MudObject> :

public class MudObjectList : List<MudObject>

其中实现了添加功能:

public void new Add(MudObject obj)
{
    obj.ContainedBy = this;
    base.Add(obj);
}

注意:此方法隐藏了旧的添加功能,而不是覆盖

通过这种方式,您可以在添加时立即填充containedby属性。当然,这意味着你所包含的 null 这意味着它是顶级对象。

最后,我认为没有必要分开 MudObject 和 Container 类,因为作为容器看起来是 泥靶 (FF使用C 3.0自动属性):

public abstract class MudObject
{
    MudObject ContainedBy { get; set; }
    MudObjectList Contains { get; set; }
}

为什么不把所有的泥巴都做成容器呢?…或者至少,根据类代码,能够包含其他对象。例如。

public abstract class MudObject
{
    MudObject containedBy;
    List<MudObject> contains;
}

然后,您可以在对象本身设置某种标志,以确定参与者是否能够真正地将事物放入或移出对象本身,而不是使用对象的类型来确定它。

事实上,把某件东西同时作为一件物品是个坏主意 和 一个容器。这打破了许多对IList进行假设的绑定场景;因此对于一个胸部,我可能会有一个items属性 在 胸部就是收藏,但让胸部只是一个胸部。

然而,对于被问到的问题…

我想让mudobject成为界面…通过这种方式,您可以使用类似以下内容的内容,它为您提供了一个包含任何具体对象的通用容器,以及自动设置父对象:

public interface IMudObject
{
    IMudObject Container { get; set; }
    /* etc */
}

public class MudContainer<T> : Collection<T>, IMudObject
    where T : IMudObject
{

    public IMudObject Container { get; set; }

    protected override void ClearItems()
    {
        foreach (T item in this)
        {
            RemoveAsContainer(item);
        }
        base.ClearItems();
    }

    protected override void InsertItem(int index, T item)
    {
        SetAsContainer(item);
        base.InsertItem(index, item);
    }

    protected override void RemoveItem(int index)
    {
        RemoveAsContainer(this[index]);
        base.RemoveItem(index);            
    }
    protected override void SetItem(int index, T item)
    {
        RemoveAsContainer(this[index]);
        SetAsContainer(item);
        base.SetItem(index, item);
    }

    void RemoveAsContainer(T item)
    {
        if (item != null && ReferenceEquals(item.Container, this))
        {
            item.Container = null;
        }
    }
    void SetAsContainer(T item)
    {
        if (item.Container != null)
        {
            throw new InvalidOperationException("Already owned!");
        }
        item.Container = this;
    }
}

在继承的基础上进行组合的想法,答案似乎已经消失了。

也许我可以做些像这样的事

public class Container<T> where T : MudObject
{
    List<T> Contains;
    MudObject containerOwner;

    public Container(MudObject owner)
    {
        containerOwner = owner;
    }
    // Other methods to handle parent association
}

public interface IMudContainer<T> where T : MudObject
{
    Container<T> Contains { get; }
}

public class MudObjectThatContainsStuff : IMudContainer
{
    public MudObjectThatContainsStuff()
    {
        Contains = new Container<MudObject>(this);
    }

    public Contains { get; }
}

按照马克的回答,写几个班级,在这个班级里保持一种双向的父子关系。