Registrieren Sie diese Unity-Abhör- & Call-Handler für alle registrierten Typen.

Question

Ich habe einen ICallHandler, den ich bei allen Unity-Container-Instanzen registrieren möchte.

Zum Beispiel, nehmen Sie die folgende Prozedur:

public class ProfilerHandler : ICallHandler 
{ 
    public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext) 
    { 
     //start timer 
     IMethodReturn methodReturn = getNext()(input, getNext); 
     //stop timer 
    } 

    public int Order 
    { 
     get; set; 
    } 
} 

und den folgenden IoC-Container-Konstruktor:

public class IoCContainer : UnityContainer 
{ 
    public IoCContainer() 
    { 
     this.RegisterType<IUserService, UserService>(new ContainerControlledLifetimeManager()); 
     this.RegisterType<IRepository<User>, UserRepository>(new ContainerControlledLifetimeManager()); 
    } 
} 

Alles, was ich tun möchte, ist diese Prozedur registriert mit all diesen Typen.

Ich kann dies tun w/einig ziemlich ausführlichen Code:

public class IoCContainer : UnityContainer 
{ 
    public IoCContainer() 
    { 
     this.AddNewExtension<Interception>(); 

     this.RegisterType<IUserService, UserService>(new ContainerControlledLifetimeManager()).Configure<Interception>().SetInterceptorFor<IUserService>(new InterfaceInterceptor()); 
     this.RegisterType<IRepository<User>, UserRepository>(new ContainerControlledLifetimeManager()).Configure<Interception>().SetInterceptorFor<IRepository<User>>(new InterfaceInterceptor()); 
    } 
} 

Aber nicht nur tun, ich habe den gleichen Interception-Code auf all meine Art Registrierungen schreiben (ich vorstellen, wenn ich mehr als 100 Typen Registrierungen habe) , aber ich muss auch eine HandlerAttribute auf jeder Schnittstelle (wieder, nicht gut, wenn ich 100+ Schnittstellen haben, um dies zu verwenden).

Ist dies meine einzige Option, oder gibt es eine Möglichkeit, dies auf Container-Ebene zu tun, um zu vermeiden, dass dies auf jede einzelne Typ-Registrierung & Schnittstelle angewendet werden muss?

Answer 1

Unity 3 bietet registration by convention, die in diesem Szenario helfen könnte:

IUnityContainer container = new UnityContainer(); 

container.AddNewExtension<Interception>(); 

container.RegisterTypes(
    AllClasses.FromLoadedAssemblies().Where(
     t => t.Namespace == "My.Namespace.Services"), 
    WithMappings.MatchingInterface, 
    getInjectionMembers: t => new InjectionMember[] 
    { 
     new Interceptor<InterfaceInterceptor>(), 
     new InterceptionBehavior<MyBehavior>() 
    }); 
} 

Sie die mit Policy Injection oben kombinieren könnten passende Regeln zu verwenden, um Ihre Anrufbehandler verkabeln. Auf diese Weise können Sie eine Vielzahl von Übereinstimmungsregeln anstelle von (oder in Kombination mit) Attributen verwenden, um zu bestimmen, welche Call-Handler zu welchen Klassen/Methoden gehören.

container.RegisterTypes(
    AllClasses.FromLoadedAssemblies().Where(
     t => t.Namespace == "My.Namespace.Services"), 
    WithMappings.MatchingInterface, 
    getInjectionMembers: t => new InjectionMember[] 
    { 
     new InterceptionBehavior<PolicyInjectionBehavior>(), 
     new Interceptor<InterfaceInterceptor>(), 
    }); 
} 

container.Configure<Interception>() 
    .AddPolicy("profiler") 
    .AddMatchingRule<AssemblyMatchingRule>(
     new InjectionConstructor(
      new InjectionParameter("My.Namespace.Services"))) 
    .AddCallHandler<ProfilerHandler>(
     new ContainerControlledLifetimeManager()); 

Einheit 2 unterstützt auch Policy Injection.

Eine Alternative zur Registrierung per Konvention wäre, eine Unity Container Extension zu schreiben, um die Überwachung während der Registrierung durchzuführen.