title: Immutable objects that reference each other?
body: <p>Today I was trying to wrap my head around immutable objects that reference each other. I came to the conclusion that you can't possibly do that without using lazy evaluation but in the process I wrote this (in my opinion) interesting code.</p>
  
  <pre><code>public class A
  {
      public string Name { get; private set; }
      public B B { get; private set; }
      public A()
      {
          B = new B(this);
          Name = "test";
      }
  }
  
  public class B
  {
      public A A { get; private set; }
      public B(A a)
      {
          //a.Name is null
          A = a;
      }
  }
  </code></pre>
  
  <p>What I find interesting is that I cannot think of another way to observe object of type A in a state that is not yet fully constructed and that includes threads. Why is this even valid? Are there any other ways to observe the state of an object that is not fully constructed?</p>