Depresyon enjeksiyonu: kısmi başlatılmış nesneler enjekte etme

Question

Bu soru Unity Container hakkındadır ancak sanırım herhangi bir bağımlılık kabına uygulanabilir.

ben dairesel bağımlılıkları ile iki sınıf vardır:

class FirstClass 
{ 
    [Dependency] 
    public SecondClass Second { get; set; } 
} 

class SecondClass 
{ 
    public readonly FirstClass First; 

    public SecondClass(FirstClass first) 
    { 
     First = first; 
    } 
} 

Teknik singletons olarak ele eğer örneğini ve doğru olarak ikisi için de bağımlılıkları enjekte etmek mümkündür:

var firstObj = new FirstClass(); 
var secondObj = new SecondClass(firstObj); 
firstObj.Second = secondObj; 

ben yapmaya çalışacağım Birlik ile aynı, StackOverflowException alır:

Birliğin beni kısmen başlatılmış nesneleri kullanmamdan korumaya çalıştığını biliyorum ama bu korumayı bir zorunluluk değil bir seçenek olarak kullanmak istiyorum.

Soru: Mevcut davranış engelli mi?

Answer 1

Dairesel bağımlılıkları bir arada kullanamazsınız.

bakınız: Bu sınıflardan birinde bağımlılıkları için tembel yükleme kullanmak olacaktır http://msdn.microsoft.com/en-us/library/cc440934.aspx

Answer 2

Tek yönlü yuvarlak:

[TestFixture] 
public class CircularUnityTest 
{ 
    IUnityContainer container; 

    [SetUp] 
    public void SetUp() 
    { 
     container = new UnityContainer(); 
     container.RegisterType(typeof(ILazy<>), typeof(Lazy<>)); 
     container.RegisterType<FirstClass>(new ContainerControlledLifetimeManager()); 
     container.RegisterType<SecondClass>(new ContainerControlledLifetimeManager()); 
    } 

    [Test] 
    public void CanResolveFirstClass() 
    { 
     var first = container.Resolve<FirstClass>(); 
     Assert.IsNotNull(first); 
    } 

    [Test] 
    public void CanResolveSecondClass() 
    { 
     var second = container.Resolve<SecondClass>(); 
     Assert.IsNotNull(second); 
    } 

    [Test] 
    public void CanGetFirstFromSecond() 
    { 
     var second = container.Resolve<SecondClass>(); 
     Assert.IsNotNull(second.First); 
    } 
} 

class FirstClass 
{ 
    [Dependency] 
    public SecondClass Second { get; set; } 
} 

class SecondClass 
{ 
    private readonly ILazy<FirstClass> lazyFirst; 

    public FirstClass First { get { return lazyFirst.Resolve(); } } 

    public SecondClass(ILazy<FirstClass> lazyFirst) 
    { 
     this.lazyFirst = lazyFirst; 
    } 
} 

public interface ILazy<T> 
{ 
    T Resolve(); 
} 

public class Lazy<T> : ILazy<T> 
{ 
    IUnityContainer container; 

    public Lazy(IUnityContainer container) 
    { 
     this.container = container; 
    } 

    public T Resolve() 
    { 
     return container.Resolve<T>(); 
    } 
} 

Answer 3

Eğer hedefe ulaşmak için yerine RegisterType arasında RegisterInstance kullanabilirsiniz. Tekil gibi davranacak - Resolve çağrıldığında her zaman aynı örneği kullanacaktır. Ben sınıfları örneğini olamayacağını Birlik sevmiyorum

class FirstClass 
{ 
    [Dependency] 
    public SecondClass Second { get; set; } 
} 

class SecondClass 
{ 
    public readonly FirstClass First; 

    public SecondClass(FirstClass first) 
    { 
     First = first; 
    } 
} 

class Program 
{ 
    static void Main(string[] args) 
    { 
     IUnityContainer container = new UnityContainer(); 
     var firstObj = new FirstClass(); 

     var secondObj = new SecondClass(firstObj); 
     firstObj.Second = secondObj; 

     // Register instance instead of type!!! 
     container.RegisterInstance<FirstClass>(firstObj); 
     container.RegisterType<SecondClass>(); 

     var first = container.Resolve<FirstClass>(); 
     var second = container.Resolve<SecondClass>(); 
    } 
} 

Şerefe,

Pavel