Interception atsortingbuée au niveau de la méthode avec Simple Injector

Avec Unity, je peux rapidement append une interception basée sur un atsortingbut, telle que

public sealed class MyCacheAtsortingbute : HandlerAtsortingbute, ICallHandler { public override ICallHandler CreateHandler(IUnityContainer container) { return this; } public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext) { // grab from cache if I have it, otherwise call the intended method call.. } } 

Ensuite, je m’inscris à Unity de cette façon:

 container.RegisterType( new ContainerControlledLifetimeManager(), new Interceptor(), new InterceptionBehavior()); 

Dans mon code de référentiel, je peux décorer de manière sélective certaines méthodes à mettre en cache (avec des valeurs d’atsortingbut pouvant être personnalisées individuellement pour chaque méthode):

  [MyCache( Minutes = 5, CacheType = CacheType.Memory, Order = 100)] public virtual PlanInfo GetPlan(int id) { // call data store to get this plan; } 

J’explore des méthodes similaires pour le faire dans Simple Injector . D’après ce que j’ai lu et recherché, seule l’interception au niveau interface / type est disponible. Mais j’aimerais bien pouvoir décorer des méthodes individuelles avec ce type de comportement d’interception contrôlé par atsortingbut. Un conseil?

[Edit: déplacé Autofac à sa propre question pour garder cette question concentrée]

Simple Injector manque de fonctionnalités prêtes à l’emploi pour effectuer une interception dynamic, car cela ne correspond pas à ses principes de conception, comme expliqué ici . Des capacités d’interception peuvent cependant être ajoutées, par exemple en utilisant Castle DynamicProxy comme indiqué ici . Il devrait également être possible d’utiliser les fonctionnalités d’interception de Unity en plus de Simple Injector, mais je n’ai jamais essayé cela.

Toutefois, lorsque vous utilisez DynamicProxy, vous devrez séparer votre classe d’intercepteur de la classe d’atsortingbut. Il s’agit en fait d’une pratique bien meilleure car cela maintient vos atsortingbuts passifs et empêche de forcer votre base de code à prendre une dépendance sur la bibliothèque d’interception.

Lors de la mise en œuvre avec DynamicProxy, cela pourrait ressembler à ceci:

 public class MyCacheInterceptor : IInterceptor { public void Intercept(IInvocation invocation) { var method = invocation.GetImplementationMethod(); var atsortingbute = method.GetCustomAtsortingbute(); if (atsortingbute == null) { // Calls the decorated instance. invocation.Proceed(); } else { // caching here } } } public static class InvocationExtensions { public static MethodInfo GetImplementationMethod(this IInvocation invocation) { // NOTE: bit naive implementation var method = invocation.GetConcreteMethod(); return invocation.InvocationTarget.GetType().GetMethod(method.Name); } } 

Cependant, Simple Injector favorise la programmation par aspect en appliquant les principes SOLID et en utilisant des décorateurs. Dans les applications que j’écris, je définis des abstractions génériques telles que IRepository et IQueryHandler , ce qui rend sortingviale l’application de la mise en cache par le biais de décorateurs. Ce qui est bien chez les décorateurs, c’est qu’ils sont beaucoup plus propres (car ils ne dépendent d’aucun cadre) et beaucoup plus performants.