假设我在同一个程序集中有以下类

public class ParentClass : IDisposable
{
  public ChildClass Child
  {
    get { return _child; }
  }
}   

public class ChildClass 
{
   public ParentClass Parent
   {
     get { return _parent; }
     set { _parent= value; }
   }

   public ChildClass (ParentClass parent)
   {
     Parent= parent;
   }

}

如果我错了请纠正我，但这是糟糕的设计。这会导致内存泄漏或其他一些不可预见的问题吗？显然垃圾收集器能够处理 such kind of circular references .

编辑

如果这两个类最终在其他类中像这样使用怎么办？

ParentClass objP = new ParentClass ();
ChildClass objC =new ChildClass(objP);
objP.Child = objC;

想法请......

最佳答案

不用担心垃圾收集器；它可以轻松处理具有任意拓扑的引用图。担心编写的对象容易违反不变量，从而导致错误。

这是一个有问题的设计，不是因为它强调了 GC——它没有——而是因为它没有强制所需的语义不变量:如果 X是 Y 的父亲，那么 Y 一定是 X 的 child 。

编写保持一致的父子关系的类可能非常棘手。我们在 Roslyn 团队所做的是，我们实际上 build 了两棵树。 “真正的”树只有子引用；没有 child 认识它的 parent 。我们在强制父子关系一致性的树之上放置一个“外观”树:当您向父节点请求其子节点时，它会在其真正的子节点之上创建一个外观并设置该外观对象的父节点成为真正的 parent 。

更新:评论者 Brian 要求提供更多详细信息。这是一个草图，说明如何在仅包含子引用的“绿色”树上实现带有子引用和父引用的“红色”外观。在这个系统中，不可能建立不一致的父子关系，如您在底部的测试代码中所见。

(我们称这些树为“红”树和“绿”树是因为在白板上绘制数据结构时，它们是我们使用的标记颜色。)

using System;

interface IValue { string Value { get; } }
interface IParent : IValue { IChild Child { get; } }
interface IChild : IValue { IParent Parent { get; } }

abstract class HasValue : IValue
{
    private string value;
    public HasValue(string value)
    {
        this.value = value;
    }
    public string Value { get { return value; } }
}

sealed class GreenChild : HasValue
{
    public GreenChild(string value) : base(value) {}
}

sealed class GreenParent : HasValue
{
    private GreenChild child;
    public GreenChild Child { get { return child; } }
    public GreenParent(string value, GreenChild child) : base(value)
    { 
         this.child = child; 
    }

    public IParent MakeFacade() { return new RedParent(this); }

    private sealed class RedParent : IParent
    {
        private GreenParent greenParent;
        private RedChild redChild;
        public RedParent(GreenParent parent) 
        { 
            this.greenParent = parent; 
            this.redChild = new RedChild(this);
        }
        public IChild Child { get { return redChild; } }
        public string Value { get { return greenParent.Value; } }

        private sealed class RedChild : IChild
        {
            private RedParent redParent;
            public RedChild(RedParent redParent)
            {
                this.redParent = redParent;
            }
            public IParent Parent { get { return redParent; } }
            public string Value 
            { 
                get 
                { 
                    return redParent.greenParent.Child.Value; 
                } 
            }
        }
    }
}
class P
{
    public static void Main()
    {
        var greenChild1 = new GreenChild("child1");
        var greenParent1 = new GreenParent("parent1", greenChild1);
        var greenParent2 = new GreenParent("parent2", greenChild1);

        var redParent1 = greenParent1.MakeFacade();
        var redParent2 = greenParent2.MakeFacade();

        Console.WriteLine(redParent1.Value); // parent1
        Console.WriteLine(redParent1.Child.Parent.Value); // parent1 !
        Console.WriteLine(redParent2.Value); // parent2
        Console.WriteLine(redParent2.Child.Parent.Value); // parent2 !

        // See how that goes? RedParent1 and RedParent2 disagree on what the
        // parent of greenChild1 is, **but they are self-consistent**. They
        // always report that the parent of their child is themselves.
    }
}

关于c# - 同一程序集中的循环引用是一件坏事吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/9604197/