분명히 어떤 시점에서 아직 생성되지 않은 다른 객체에 연결 해야하는 객체를 생성해야하기 때문에 게시 한 코드를 사용하여 정확히 수행 할 수는 없습니다.

이것을하기 위해 내가 생각할 수있는 두 가지 방법이있다 :

두 단계 사용

모든 개체는 종속성없이 먼저 구성되며 모든 개체가 구성되면 연결됩니다. 이것은 객체가 인생에서 두 단계를 거쳐야한다는 것을 의미합니다 : 매우 짧은 가변 단계 다음에 수명이 다할 때까지 지속되는 불변 단계.

관계형 데이터베이스를 모델링 할 때 똑같은 종류의 문제가 발생할 수 있습니다. 한 테이블에는 다른 테이블을 가리키는 외래 키가 있고 다른 테이블에는 첫 번째 테이블을 가리키는 외래 키가있을 수 있습니다. 이것이 관계형 데이터베이스에서 처리되는 방식은 외래 키 제약 조건이 ALTER TABLE ADD FOREIGN KEY명령문 과 별도의 추가 명령문으로 지정할 수 있고 일반적으로 지정 되는 것입니다 CREATE TABLE. 따라서 먼저 모든 테이블을 만든 다음 외래 키 제약 조건을 추가하십시오.

관계형 데이터베이스와 수행하려는 작업의 차이점은 관계형 데이터베이스 ALTER TABLE ADD/DROP FOREIGN KEY는 테이블 수명 동안 명령문을 계속 허용 하지만 모든 종속성이 실현되면 ‘IamImmutable’플래그를 설정하고 추가 변이를 거부한다는 것입니다.

지연 초기화 사용

종속성에 대한 참조 대신 필요한 경우 종속성에 대한 참조를 반환 하는 대리자 를 전달 합니다. 종속성이 페치되면 델리게이트는 다시 호출되지 않습니다.

대리자는 일반적으로 람다 식의 형태를 취하므로 실제로 생성자에 종속성을 전달하는 것보다 약간 더 장황하게 보입니다.

이 기술의 단점은 객체 그래프를 초기화하는 동안에 만 사용되는 델리게이트에 대한 포인터를 저장하는 데 필요한 저장 공간을 낭비해야한다는 것입니다.

이를 구현하는 일반 “게으른 참조”클래스를 만들 수도 있으므로 멤버마다 하나씩 다시 구현할 필요가 없습니다.

Java로 작성된 클래스는 다음과 같습니다. C #으로 쉽게 작성할 수 있습니다.

(내 C # Function<T>의 Func<T>대표 와 같습니다 )

package saganaki.util;

import java.util.Objects;

/**
 * A {@link Function} decorator which invokes the given {@link Function} only once, when actually needed, and then caches its result and never calls it again.
 * It behaves as if it is immutable, which includes the fact that it is thread-safe, provided that the given {@link Function} is also thread-safe.
 *
 * @param <T> the type of object supplied.
 */
public final class LazyImmutable<T> implements Function<T>
{
    private static final boolean USE_DOUBLE_CHECK = false; //TODO try with "double check"
    private final Object lock = new Object();
    @SuppressWarnings( "FieldAccessedSynchronizedAndUnsynchronized" )
    private Function<T> supplier;
    @SuppressWarnings( "FieldAccessedSynchronizedAndUnsynchronized" )
    private T value;

    /**
     * Constructor.
     *
     * @param supplier the {@link Function} which will supply the supplied object the first time it is needed.
     */
    public LazyImmutable( Function<T> supplier )
    {
        assert supplier != null;
        assert !(supplier instanceof LazyImmutable);
        this.supplier = supplier;
        value = null;
    }

    @Override
    public T invoke()
    {
        if( USE_DOUBLE_CHECK )
        {
            if( supplier != null )
                doCheck();
            return value;
        }

        doCheck();
        return value;
    }

    private void doCheck()
    {
        synchronized( lock )
        {
            if( supplier != null )
            {
                value = supplier.invoke();
                supplier = null;
            }
        }
    }

    @Override
    public String toString()
    {
        if( supplier != null )
            return "(lazy)";
        return Objects.toString( value );
    }
}

이 클래스는 스레드로부터 안전해야하며 “더블 체크”항목은 동시성의 경우 최적화와 관련이 있습니다. 다중 스레드를 계획하지 않을 경우 모든 것을 제거 할 수 있습니다. 다중 스레드 설정에서이 클래스를 사용하기로 결정한 경우 “더블 체크 관용구”에 대해 읽어보십시오. (이 질문의 범위를 벗어나는 긴 토론입니다.)

답변

Room library = new Room("Library");
Room ballroom = new Room("Ballroom");
Thing chest = new Thing("Treasure chest");
Thing book = new Thing("Ancient Tome");
Dungeon dungeon = Dungeon.Empty
  .WithRoom(library)
  .WithRoom(ballroom)
  .WithThing(chest)
  .WithThing(book)
  .WithPassage("North", library, ballroom)
  .WithPassage("South", ballroom, library)
  .WithContainment(library, chest)
  .WithContainment(chest, book);

A a = new A(b);
B b = new B(a);

A a = new A();
B b = new B(a);
a.setB(b);

C c = new C();
A a = new A(c);
B b = new B(c);
c.addA(a);
c.addB(b);

A a = new A();
B b = new B(a);
a.addB(b);
a.freeze();