Tiêm phụ thuộc: tiêm các đối tượng được khởi tạo một phần

Question

Câu hỏi này là về Unity Container nhưng tôi đoán nó có thể áp dụng cho bất kỳ container phụ thuộc nào.

Tôi có hai lớp với phụ thuộc vòng tròn:

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

class SecondClass 
{ 
    public readonly FirstClass First; 

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

Về mặt kỹ thuật nó có thể nhanh chóng và chính xác tiêm phụ thuộc cho cả hai nếu đối xử với họ như độc thân:

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

Khi tôi cố gắng làm tương tự với Unity, tôi nhận được StackOverflowException:

var container = new UnityContainer(); 
container.RegisterType<FirstClass>(new ContainerControlledLifetimeManager()); 
container.RegisterType<SecondClass>(new ContainerControlledLifetimeManager()); 

var first = container.Resolve<FirstClass>(); // StackOverflowException here! 
var second = container.Resolve<SecondClass>(); // StackOverflowException here too! 

Tôi hiểu rằng Unity cố gắng bảo vệ tôi khỏi việc sử dụng các đối tượng được khởi tạo một phần nhưng tôi muốn có sự bảo vệ này như một lựa chọn, không phải là một nghĩa vụ.

Câu hỏi: hành vi hiện tại có thể không thể thực hiện được không?

Answer 1

Tôi nghĩ bạn không thể sử dụng phụ thuộc vòng tròn với sự đoàn kết chút nào.

Xem: http://msdn.microsoft.com/en-us/library/cc440934.aspx

Answer 2

Một cách vòng này sẽ được sử dụng tải lười biếng cho sự phụ thuộc vào một trong các lớp:

[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

bạn có thể sử dụng RegisterInstance thay vì RegisterType để đạt được mục tiêu của bạn. Nó sẽ hoạt động giống như singleton - sẽ sử dụng cùng một cá thể mỗi khi Resolve được gọi. Hãy xem ví dụ sau:

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>(); 
    } 
} 

Chúc mừng,

Pavel