Iniezione di priorità: iniezione di oggetti parzialmente inizializzati

Question

Questa domanda riguarda il contenitore di unità, ma suppongo che sia applicabile a qualsiasi contenitore di dipendenze.

ho due classi con dipendenze circolari:

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

class SecondClass 
{ 
    public readonly FirstClass First; 

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

Tecnicamente è possibile istanziare e iniettare dipendenze per entrambi correttamente se trattarli come singletons:

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

Quando provo a fare lo stesso con Unity, ottengo 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! 

Capisco che Unity cerchi di proteggermi dall'usare oggetti parzialmente inizializzati, ma voglio avere questa protezione come un'opzione, non un obbligo.

Domanda: il comportamento corrente non è adatto?

Answer 1

Penso che non sia possibile utilizzare le dipendenze circolari con l'unità.

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

Answer 2

Un modo intorno a questo sarebbe quella di utilizzare lazy loading per le dipendenze su una delle classi:

[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

è possibile utilizzare registerInstance invece di RegisterType per raggiungere il tuo obiettivo. Si comporterà proprio come Singleton - utilizzerà la stessa istanza ogni volta che viene invocato Resolve. Date un'occhiata a questo esempio:

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

Cheers,

Pavel