Castle windsor Auflösung Pipeline mit Unity als Unter-Resolver

Question

Kurz gesagt versuche ich Castle Windsor Container mit Unity Container zu verknüpfen. Lassen Sie mich den Kontext erklären:

Ich habe ein Projekt, in dem für sehr lange Zeit Schloss Windsor verwendet. Vor ein paar Tagen habe ich eine Menge DLLs bekommen, die ich aus meinem alten Projekt konsumieren muss. Diese DLLs verwenden Unity Container als ihren Injektionsmechanismus. Ich habe auch Zugriff auf Schnittstellen/Implementierungen, die in diesen DLLs gefunden werden, aber ich würde nicht versuchen, Implementierungen manuell zu instantiieren, aber ich würde es vorziehen, wenn möglich, den Unity-Container mit meinem aktuellen Castle-Windsor-Container zu verknüpfen. Wie könnte ich das erreichen?

Also, wenn ich habe:

public class MyService: IService 
{ 
    public MyService (IThidPartyService thirdParty) 
    { 

    } 
} 

Wenn ich IService mit windsor lösen wäre es schön, dass IThirdPartyService von den anderen Behältern gelöst werden: Unity.

Vielen Dank !.

Answer 1

Ich denke, das ist ein perfektes Beispiel für die Verwendung eines benutzerdefinierten ISubDependencyResolver. Immer wenn Castle nicht weiß, wie eine bestimmte Abhängigkeit gelöst werden kann, wird dieser benutzerdefinierte Resolver angesprochen. Dieser neue Resolver hängt vom Unity-Container ab und verwendet ihn, um "for" Castle aufzulösen.

Castle's documentation heißt es:

Falls frühere Orte nicht in der Lage waren die Abhängigkeit Resolver lösen wird jedes ihrer Unter Resolvern (ISubDependencyResolver) fragen, ob sie die Abhängigkeit zur Verfügung stellen kann.

Wenn diese Abhängigkeit nicht in Castle gefunden wird, sucht sie Ihren neuen Resolver, der die Abhängigkeit bereitstellt. Hier

ist ein funktionierendes Beispiel mit beiden Constructor Injection und Property Injection:

class Program 
{ 
    static void Main(string[] args) 
    { 
     var unityContainer = new UnityContainer(); 
     unityContainer.RegisterType<IDependency, Dependency1>(); 
     unityContainer.RegisterType<IPropertyDependency, PropertyDependency1>(); 

     WindsorContainer castleContainer = new WindsorContainer(); 
     castleContainer.Kernel.Resolver.AddSubResolver(new UnityResolver(unityContainer)); 
     castleContainer.Register(
      Component.For<SomeType>()); 

     var result = castleContainer.Resolve<SomeType>(); 
    } 
} 

public interface IDependency { void Foo(); } 
public class Dependency1 : IDependency { public void Foo() { } } 

public interface IPropertyDependency { } 
public class PropertyDependency1 : IPropertyDependency { } 
public class SomeType 
{ 
    public SomeType(IDependency dependency) { ConstructorDependency = dependency; } 

    public IDependency ConstructorDependency { get; private set; } 
    public IPropertyDependency PropertyDependency { get; set; } 
} 

public class UnityResolver : ISubDependencyResolver 
{ 
    public UnityResolver(UnityContainer container) 
    { 
     Container = container; 
    } 
    public bool CanResolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency) 
    { 
     return Container.Registrations.Any(z => z.RegisteredType.Equals(dependency.TargetType)); 
    } 

    public object Resolve(CreationContext context, ISubDependencyResolver contextHandlerResolver, ComponentModel model, DependencyModel dependency) 
    { 
     return Container.Resolve(dependency.TargetType); 
    } 

    public UnityContainer Container { get; set; } 
} 

Und das Ergebnis:

Wie für den Code für die Überprüfung Unity für die CanResolve - Ich bin sicher, dass es verbessert werden kann - ich nicht k jetzt viel über Unity