Wie man IUnityContainer mit einem anderen IUnityContainer verschmelzen kann

Question

Ich habe einen Anwendungsfall, in dem meine Firma von einer alten Codebasis zu einer neuen älteren Codebasis wechselt. Die Kombination ist instabil, das Zusammenführen der Container würde helfen.

Ich identifizierte einen Punkt, wo ich die Container zusammenführen und einen neuen Container an die verbleibende Anwendung übergeben möchte.

Ich habe Grund zu der Annahme, dass ich alte Typen überschreiben kann, ohne Probleme zu verursachen.

Wie kann ich eine IUnityContainer mit einer anderen IUnityContainer zusammenführen?

Das Folgende ist, wie weit meine Experimente haben mich genommen:

using Microsoft.Practices.Unity; 
using System; 
using System.Collections.Generic; 
using System.Linq; 

class ContainerUser 
{ 
    public ContainerUser(IEnumerable<IUnityContainer> chaos) 
    { 
     IUnityContainer combined = new UnityContainer(); 
     //is there a highlevel method that can be used? 
     //or is a foreach loop the way to go 
     foreach (var uc in chaos) 
     { 
      foreach (var reg in uc.Registrations) 
      { 
       //combined.Register...??? 
       //usure what to so here 
      } 
     } 
     //this throws unless combining the conainers works 
     combined.Resolve<L1>().Exec(); 
     combined.Resolve<L2>().Exec(); 
    } 
} 

class L1 
{ 
    private L1() { } //private so UnityContainer can not default construct 
    public static L1 Get() { return new L1(); } //getter for InjectionFactory 
    public void Exec() { Console.WriteLine("L1"); } 
} 

class L2 
{ 
    private L2() { } 
    public static L2 Get() { return new L2(); } 
    public void Exec() { Console.WriteLine("L2"); } 
} 

class Program 
{ 
    public static IEnumerable<T> Randomize<T>(IEnumerable<T> source) 
    { 
     //randomize to show i do not know a lot about my different containers 
     Random rnd = new Random(); 
     return source.OrderBy<T, int>((item) => rnd.Next()); 
    } 

    static void Main(string[] args) 
    { 
     //this is the setup, in my usecase these things happe behind the scenes and i can not influence them. 
     var ucs = new List<IUnityContainer> { new UnityContainer(), new UnityContainer() }; 

     ucs[0].RegisterType<L1>(new InjectionFactory(c => L1.Get())); 
     ucs[0].Resolve<L1>().Exec(); //proof L1 can resolve 

     ucs[1].RegisterType<L2>(new InjectionFactory(c => L2.Get())); 
     ucs[1].Resolve<L2>().Exec(); //proof L2 can resolve 

     ContainerUser user = new ContainerUser(Randomize(ucs)); 
    } 
} 

Answer 1

Dies ist ein einfacher Ansatz, wie Erweiterungen verwenden Container fusionieren:

public class MergeContainerExtension : UnityContainerExtension 
{ 
    private readonly IUnityContainer[] containers; 

    public MergeContainerExtension(params IUnityContainer[] containers) 
    { 
     this.containers = containers; 
    } 
    protected override void Initialize() 
    { 
     foreach (var container in containers) 
     { 
      foreach (var registration in container.Registrations) 
      { 
       base.Container. 
        RegisterType(
        registration.RegisteredType, 
        registration.MappedToType, 
        registration.Name, 
        registration.LifetimeManager); 
      } 
     } 
    } 
} 
class Program 
{ 
    static void Main(string[] args) 
    { 
     UnityContainer aContainer = new UnityContainer(); 
     UnityContainer bContainer = new UnityContainer(); 


     UnityContainer container = new UnityContainer(); 
     MergeContainerExtension mergeExtension = new MergeContainerExtension(aContainer, bContainer); 
     container.AddExtension(mergeExtension); 


     var resolve = container.Resolve<IClassA>(); 
    } 
}