Unity IOC Buildup vs Resolve?

Question

Mi chiedevo quando utilizzare l'accumulo e quando uso risoluzione, quando si utilizza l'Unity IOC.

E quando si chiama teardown?

Grazie

Answer 1

Resolve viene utilizzato quando si desidera che il contenitore Unità di costruire l'istanza (uno nuovo solo quando ne hai bisogno o di un pre-esistente Singleton), iniettare le sue dipendenze e consegnare il riferimento all'oggetto .

BuildUp viene utilizzato quando si dispone già di un'istanza dell'oggetto e si desidera che il contenitore risolva e inietti le sue dipendenze.

Teardown è l'opposto di BuildUp. Puoi passare il tuo oggetto al metodo Teardown del contenitore per chiudere/ripulire/tutto ciò che vuoi. Il comportamento del contenitore esistente non fa nulla al momento del Teardown, ma è possibile scrivere estensioni per trarne vantaggio. È inoltre possibile rendere gli oggetti implementabili IDisposable e il contenitore chiamerà Dispose() sull'oggetto quando viene eliminato.

IMyService service = container.Resolve<MyService>(); // New service or pre-existing singleton 

IMyService service = GetMyService(); // Get the instance from some source 
container.BuildUp(service); // Inject dependencies 
container.Teardown(service); // Clean-up 

Answer 2

avere ciò Rafa detto risulta evidente che a differenza Resolve()BuildUp() non aiuta con iniezione ctor. Uno scenario comune è quando crei il tuo oggetto da qualche parte all'esterno, passalo come parametro e costruiscilo dentro. (Esterno e interno si riferiscono al corpo di un metodo.) Inoltre, potrebbe essere necessario chiamare Teardown() per pulire l'oggetto e ripristinarlo allo stato in cui era prima di passare come parametro. Attenzione però, dal momento che Unity è costruito in Teardown() non fa nulla, è una specie di segnaposto adatto per la sovrascrittura.

Un exampe potrebbe essere un oggetto stampante. Dopo averlo creato, lo si chiama in una serie di altri metodi ogni volta che si immette l'intestazione/piè di pagina diversa:

public class Decorations 
{ 
    public string Header { get; set; } 

    public string Footer { get; set; } 
} 

public class Printer 
{ 
    internal void Print(string message) 
    { 
     Console.WriteLine("HEADER: {0}", this.Decorations != null 
      && this.Decorations.Header != null 
       ? this.Decorations.Header 
       : string.Empty); 
     Console.WriteLine(message); 
     Console.WriteLine("FOOTER: {0}", this.Decorations != null 
      && this.Decorations.Footer != null 
       ? this.Decorations.Footer 
       : string.Empty); 
    } 

    [Dependency] 
    public Decorations Decorations { get; set; } 
} 

public class ClassA 
{ 
    public void Print(Printer printer, IUnityContainer container) 
    { 
     container.BuildUp(printer); 
     printer.Print("Hello from ClassA"); 
     container.Teardown(printer); 
    } 
} 

public class Program 
{ 
    private static void Main(string[] args) 
    { 
     var printer = new Printer(); 

     var containerA = new UnityContainer(); 
     containerA.RegisterInstance(new Decorations { 
      Header = "I am HEADER from Decorations #1", 
      Footer = "I am FOOTER from Decorations #1" }); 
     var containerB = new UnityContainer(); 
     containerB.RegisterInstance(new Decorations { 
      Header = "--- I am HEADER from Decorations #2 ---", 
      Footer = "--- I am FOOTER from Decorations #2 ---" }); 

     var a = new ClassA(); 

     a.Print(printer, containerA); 
     a.Print(printer, containerB); 

     Console.WriteLine("Press any key to continue..."); 
     Console.ReadKey(); 
    } 
}