New code interception policy variants, new extensions

DanNsk · DanNsk · commit c1d21f368f2d · 2012-02-10T14:38:08.000+07:00
diff --git a/MvcInterception.Unity/MethodMatchingRule.cs b/MvcInterception.Unity/MethodMatchingRule.cs
@@ -1,28 +1,42 @@
+using System;
 using System.Reflection;
 using Microsoft.Practices.Unity.InterceptionExtension;
 
 namespace MvcInterception.Unity
 {
     public class MethodMatchingRule : IMatchingRule
     {
-        public MethodMatchingRule()
+        public MethodMatchingRule(MethodBase method)
+            : this(x => x.Equals(method))
         {
+            
         }
 
-        public MethodMatchingRule(MethodInfo method)
+        public MethodMatchingRule(Predicate<MethodBase> method)
         {
-            Method = method;
+            MethodEqChecker = method;
         }
 
-        public MethodInfo Method
+
+        public static MethodMatchingRule Create(Predicate<MethodBase> methodChecker, MethodBase method)
+        {
+            if (methodChecker != null)
+                return new MethodMatchingRule(methodChecker);
+            if (method != null)
+                return new MethodMatchingRule(method);
+
+            return null;
+        }
+
+        public Predicate<MethodBase> MethodEqChecker
         {
             get;
             set;
         }
 
         public bool Matches(MethodBase member)
         {
-            return member.Equals(Method);
+            return MethodEqChecker(member);
         }
     }
 }
diff --git a/MvcInterception.Unity/UnityCallInterceptorRegistry.cs b/MvcInterception.Unity/UnityCallInterceptorRegistry.cs
@@ -32,15 +32,28 @@ protected Interception InterceptionExtension
             }
         }
 
-        protected override void RegisterMethod(MethodInfo method, Type type, IEnumerable objects)
+        protected override void RegisterMethod<TObj>(Predicate<MethodBase> methodPred, MethodBase method, IEnumerable objects)
         {
-            var policyName = type.FullName + "." + method.Name + ", " + type.Assembly.FullName;
+            var type = method == null ? typeof(TObj) : method.ReflectedType;
+
+            string mname = null;
+
+            if (method != null)
+            {
+                mname = "." + method.Name;
+            }
+            else if (methodPred != null)
+            {
+                mname = "[" + methodPred.Method.ReflectedType.FullName + "." + methodPred.Method.Name + "]";
+            }
+
+            var policyName = type.FullName + mname + ", " + type.Assembly.FullName;
 
             PolicyDefinition policy;
 
             if (!cachePolicy.TryGetValue(policyName, out policy))
             {
-                Interception interceptionExtension = null;
+                Interception interceptionExtension;
 
                 if (transparentProxyInterceptor.CanIntercept(type))
                     interceptionExtension = InterceptionExtension.SetInterceptorFor(type, transparentProxyInterceptor);
@@ -49,7 +62,7 @@ protected override void RegisterMethod(MethodInfo method, Type type, IEnumerable
                 else
                     interceptionExtension = InterceptionExtension.SetInterceptorFor(type, virtualMethodInterceptor);
 
-                policy = interceptionExtension.AddPolicy(policyName).AddMatchingRule(new MethodMatchingRule(method));
+                policy = interceptionExtension.AddPolicy(policyName).AddMatchingRule(MethodMatchingRule.Create(methodPred, method));
 
                 cachePolicy.Add(policyName, policy);
             }
diff --git a/MvcInterception/CallInterceptorRegistry.cs b/MvcInterception/CallInterceptorRegistry.cs
@@ -19,17 +19,24 @@ public ContainerAdapter Container
             set;
         }
 
-        public ICallInterceptorRegistry RegisterObjects<TObj>(Expression<Action<TObj>> action, params object[] objs)
+        public ICallInterceptorRegistry RegisterInterceptors<TObj>(Expression<Action<TObj>> action, params object[] objs)
         {
             var methodCall = action.Body as MethodCallExpression;
 
-            RegisterMethod(methodCall.Method, methodCall.Object.Type, ConvertInputObjects(objs));
+            RegisterMethod<TObj>(null, methodCall.Method, ConvertInputObjects(objs));
+
+            return this;
+        }
+
+        public ICallInterceptorRegistry RegisterInterceptors<TObj>(Predicate<MethodBase> methodPred, params object[] objs)
+        {
+            RegisterMethod<TObj>(methodPred, null, ConvertInputObjects(objs));
 
             return this;
         }
 
         protected abstract IEnumerable ConvertInputObjects(IEnumerable objs);
 
-        protected abstract void RegisterMethod(MethodInfo method, Type type, IEnumerable objects);
+        protected abstract void RegisterMethod<TObj>(Predicate<MethodBase> methodPred, MethodBase method, IEnumerable objects);
     }
 }
diff --git a/MvcInterception/CallInterceptorRegistryExpressionExtensions.cs b/MvcInterception/CallInterceptorRegistryExpressionExtensions.cs
@@ -5,37 +5,37 @@
 
 namespace MvcInterception
 {
-    public static class CallInterceptorRegistryExtensions
+    public static class CallInterceptorRegistryExpressionExtensions
     {
         public static ICallInterceptorRegistry Register<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, params ICallInterceptor[] objs)
         {
-            return Register(@this, action, (IEnumerable<ICallInterceptor>)objs);
+            return @this.Register(action, (IEnumerable<ICallInterceptor>)objs);
         }
 
         public static ICallInterceptorRegistry Register<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, IEnumerable<ICallInterceptor> objs)
         {
-            return @this.RegisterObjects(action, objs.Cast<object>().ToArray());
+            return @this.RegisterInterceptors(action, objs.Cast<object>().ToArray());
         }
 
         public static ICallInterceptorRegistry Register<TObj, T1>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action)
             where T1: ICallInterceptor, new()
         {
-            return @this.RegisterObjects(action, typeof(T1));
+            return @this.RegisterInterceptors(action, typeof(T1));
         }
 
         public static ICallInterceptorRegistry Register<TObj, T1, T2>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action)
             where T1 : ICallInterceptor, new()
             where T2 : ICallInterceptor, new()
         {
-            return @this.RegisterObjects(action, typeof(T1), typeof(T2));
+            return @this.RegisterInterceptors(action, typeof(T1), typeof(T2));
         }
 
         public static ICallInterceptorRegistry Register<TObj, T1, T2, T3>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action)
             where T1 : ICallInterceptor, new()
             where T2 : ICallInterceptor, new()
             where T3 : ICallInterceptor, new()
         {
-            return @this.RegisterObjects(action, typeof(T1), typeof(T2), typeof(T3));
+            return @this.RegisterInterceptors(action, typeof(T1), typeof(T2), typeof(T3));
         }
 
         public static ICallInterceptorRegistry Register<TObj, T1, T2, T3, T4>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action)
@@ -44,42 +44,27 @@ public static ICallInterceptorRegistry Register<TObj, T1, T2, T3, T4>(this ICall
             where T3 : ICallInterceptor, new()
             where T4 : ICallInterceptor, new()
         {
-            return @this.RegisterObjects(action, typeof(T1), typeof(T2), typeof(T3), typeof(T4));
+            return @this.RegisterInterceptors(action, typeof(T1), typeof(T2), typeof(T3), typeof(T4));
         }
 
         public static ICallInterceptorRegistry Register<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, Predicate<IActionInvocation> before, Action<IActionReturn> after)
         {
-            return @this.RegisterObjects(action, new DelegatedCallInterceptor(before, after));
-        }
-
-        public static ICallInterceptorRegistry Register<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, Action<IActionInvocation> before)
-        {
-            return Register(@this, action, x => { before(x); return true; }, null);
-        }
-
-        public static ICallInterceptorRegistry Register<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, Predicate<IActionInvocation> before)
-        {
-            return Register(@this, action, before, null);
-        }
-
-        public static ICallInterceptorRegistry Register<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, Action<IActionReturn> after)
-        {
-            return Register(@this, action, null, after);
+            return @this.RegisterInterceptors(action, new DelegatedCallInterceptor(before, after));
         }
 
         public static ICallInterceptorRegistry RegisterBefore<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, Action<IActionInvocation> before)
         {
-            return Register(@this, action, x => { before(x); return true; }, null);
+            return @this.Register(action, x => { before(x); return true; }, null);
         }
 
         public static ICallInterceptorRegistry RegisterBeforeCancellable<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, Predicate<IActionInvocation> before)
         {
-            return Register(@this, action, before, null);
+            return @this.Register(action, before, null);
         }
 
         public static ICallInterceptorRegistry RegisterAfter<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, Action<IActionReturn> after)
         {
-            return Register(@this, action, null, after);
+            return @this.Register(action, null, after);
         }
     }
 }
diff --git a/MvcInterception/CallInterceptorRegistryMethodExtensions.cs b/MvcInterception/CallInterceptorRegistryMethodExtensions.cs
@@ -0,0 +1,70 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+namespace MvcInterception
+{
+    public static class CallInterceptorRegistryMethodExtensions
+    {
+        public static ICallInterceptorRegistry Register<TObj>(this ICallInterceptorRegistry @this, Predicate<MethodBase> methodPred, params ICallInterceptor[] objs)
+        {
+            return @this.Register<TObj>(methodPred, (IEnumerable<ICallInterceptor>)objs);
+        }
+
+        public static ICallInterceptorRegistry Register<TObj>(this ICallInterceptorRegistry @this, Predicate<MethodBase> methodPred, IEnumerable<ICallInterceptor> objs)
+        {
+            return @this.RegisterInterceptors<TObj>(methodPred, objs.Cast<object>().ToArray());
+        }
+
+        public static ICallInterceptorRegistry Register<TObj, T1>(this ICallInterceptorRegistry @this, Predicate<MethodBase> methodPred)
+            where T1: ICallInterceptor, new()
+        {
+            return @this.RegisterInterceptors<TObj>(methodPred, typeof(T1));
+        }
+
+        public static ICallInterceptorRegistry Register<TObj, T1, T2>(this ICallInterceptorRegistry @this, Predicate<MethodBase> methodPred)
+            where T1 : ICallInterceptor, new()
+            where T2 : ICallInterceptor, new()
+        {
+            return @this.RegisterInterceptors<TObj>(methodPred, typeof(T1), typeof(T2));
+        }
+
+        public static ICallInterceptorRegistry Register<TObj, T1, T2, T3>(this ICallInterceptorRegistry @this, Predicate<MethodBase> methodPred)
+            where T1 : ICallInterceptor, new()
+            where T2 : ICallInterceptor, new()
+            where T3 : ICallInterceptor, new()
+        {
+            return @this.RegisterInterceptors<TObj>(methodPred, typeof(T1), typeof(T2), typeof(T3));
+        }
+
+        public static ICallInterceptorRegistry Register<TObj, T1, T2, T3, T4>(this ICallInterceptorRegistry @this, Predicate<MethodBase> methodPred)
+            where T1 : ICallInterceptor, new()
+            where T2 : ICallInterceptor, new()
+            where T3 : ICallInterceptor, new()
+            where T4 : ICallInterceptor, new()
+        {
+            return @this.RegisterInterceptors<TObj>(methodPred, typeof(T1), typeof(T2), typeof(T3), typeof(T4));
+        }
+
+        public static ICallInterceptorRegistry Register<TObj>(this ICallInterceptorRegistry @this, Predicate<MethodBase> methodPred, Predicate<IActionInvocation> before, Action<IActionReturn> after)
+        {
+            return @this.RegisterInterceptors<TObj>(methodPred, new DelegatedCallInterceptor(before, after));
+        }
+
+        public static ICallInterceptorRegistry RegisterBefore<TObj>(this ICallInterceptorRegistry @this, Predicate<MethodBase> methodPred, Action<IActionInvocation> before)
+        {
+            return @this.Register<TObj>(methodPred, x => { before(x); return true; }, null);
+        }
+
+        public static ICallInterceptorRegistry RegisterBeforeCancellable<TObj>(this ICallInterceptorRegistry @this, Predicate<MethodBase> methodPred, Predicate<IActionInvocation> before)
+        {
+            return @this.Register<TObj>(methodPred, before, null);
+        }
+
+        public static ICallInterceptorRegistry RegisterAfter<TObj>(this ICallInterceptorRegistry @this, Predicate<MethodBase> methodPred, Action<IActionReturn> after)
+        {
+            return @this.Register<TObj>(methodPred, null, after);
+        }
+    }
+}
diff --git a/MvcInterception/ICallInterceptorRegistry.cs b/MvcInterception/ICallInterceptorRegistry.cs
@@ -1,5 +1,6 @@
 ﻿using System;
 using System.Linq.Expressions;
+using System.Reflection;
 using MvcExtensions;
 
 namespace MvcInterception
@@ -12,6 +13,8 @@ ContainerAdapter Container
             set;
         }
 
-        ICallInterceptorRegistry RegisterObjects<TObj>(Expression<Action<TObj>> action, params object[] objs);
+        ICallInterceptorRegistry RegisterInterceptors<TObj>(Expression<Action<TObj>> action, params object[] objs);
+
+        ICallInterceptorRegistry RegisterInterceptors<TObj>(Predicate<MethodBase> methodPred, params object[] objs);
     }
 }
diff --git a/MvcInterception/MvcInterception.csproj b/MvcInterception/MvcInterception.csproj
@@ -61,8 +61,9 @@
     <Compile Include="ActionParameter.cs" />
     <Compile Include="ActionReturn.cs" />
     <Compile Include="CallInterceptorRegistry.cs" />
-    <Compile Include="CallInterceptorRegistryExtensions.cs" />
+    <Compile Include="CallInterceptorRegistryExpressionExtensions.cs" />
     <Compile Include="ConfigureCallInterceptorsBase.cs" />
+    <Compile Include="CallInterceptorRegistryMethodExtensions.cs" />
     <Compile Include="DelegatedCallInterceptor.cs" />
     <Compile Include="ICallInterceptor.cs" />
     <Compile Include="IActionInvocation.cs" />

Original file line number	Diff line number	Diff line change
`@@ -1,28 +1,42 @@`
	`1`	`+using System;`
`1`	`2`	`using System.Reflection;`
`2`	`3`	`using Microsoft.Practices.Unity.InterceptionExtension;`
`3`	`4`
`4`	`5`	`namespace MvcInterception.Unity`
`5`	`6`	`{`
`6`	`7`	`public class MethodMatchingRule : IMatchingRule`
`7`	`8`	`{`
`8`		`- public MethodMatchingRule()`
	`9`	`+ public MethodMatchingRule(MethodBase method)`
	`10`	`+ : this(x => x.Equals(method))`
`9`	`11`	`{`
	`12`	`+`
`10`	`13`	`}`
`11`	`14`
`12`		`- public MethodMatchingRule(MethodInfo method)`
	`15`	`+ public MethodMatchingRule(Predicate<MethodBase> method)`
`13`	`16`	`{`
`14`		`- Method = method;`
	`17`	`+ MethodEqChecker = method;`
`15`	`18`	`}`
`16`	`19`
`17`		`- public MethodInfo Method`
	`20`	`+`
	`21`	`+ public static MethodMatchingRule Create(Predicate<MethodBase> methodChecker, MethodBase method)`
	`22`	`+ {`
	`23`	`+ if (methodChecker != null)`
	`24`	`+ return new MethodMatchingRule(methodChecker);`
	`25`	`+ if (method != null)`
	`26`	`+ return new MethodMatchingRule(method);`
	`27`	`+`
	`28`	`+ return null;`
	`29`	`+ }`
	`30`	`+`
	`31`	`+ public Predicate<MethodBase> MethodEqChecker`
`18`	`32`	`{`
`19`	`33`	`get;`
`20`	`34`	`set;`
`21`	`35`	`}`
`22`	`36`
`23`	`37`	`public bool Matches(MethodBase member)`
`24`	`38`	`{`
`25`		`- return member.Equals(Method);`
	`39`	`+ return MethodEqChecker(member);`
`26`	`40`	`}`
`27`	`41`	`}`
`28`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,17 +19,24 @@ public ContainerAdapter Container`
`19`	`19`	`set;`
`20`	`20`	`}`
`21`	`21`
`22`		`- public ICallInterceptorRegistry RegisterObjects<TObj>(Expression<Action<TObj>> action, params object[] objs)`
	`22`	`+ public ICallInterceptorRegistry RegisterInterceptors<TObj>(Expression<Action<TObj>> action, params object[] objs)`
`23`	`23`	`{`
`24`	`24`	`var methodCall = action.Body as MethodCallExpression;`
`25`	`25`
`26`		`- RegisterMethod(methodCall.Method, methodCall.Object.Type, ConvertInputObjects(objs));`
	`26`	`+ RegisterMethod<TObj>(null, methodCall.Method, ConvertInputObjects(objs));`
	`27`	`+`
	`28`	`+ return this;`
	`29`	`+ }`
	`30`	`+`
	`31`	`+ public ICallInterceptorRegistry RegisterInterceptors<TObj>(Predicate<MethodBase> methodPred, params object[] objs)`
	`32`	`+ {`
	`33`	`+ RegisterMethod<TObj>(methodPred, null, ConvertInputObjects(objs));`
`27`	`34`
`28`	`35`	`return this;`
`29`	`36`	`}`
`30`	`37`
`31`	`38`	`protected abstract IEnumerable ConvertInputObjects(IEnumerable objs);`
`32`	`39`
`33`		`- protected abstract void RegisterMethod(MethodInfo method, Type type, IEnumerable objects);`
	`40`	`+ protected abstract void RegisterMethod<TObj>(Predicate<MethodBase> methodPred, MethodBase method, IEnumerable objects);`
`34`	`41`	`}`
`35`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,37 +5,37 @@`
`5`	`5`
`6`	`6`	`namespace MvcInterception`
`7`	`7`	`{`
`8`		`- public static class CallInterceptorRegistryExtensions`
	`8`	`+ public static class CallInterceptorRegistryExpressionExtensions`
`9`	`9`	`{`
`10`	`10`	`public static ICallInterceptorRegistry Register<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, params ICallInterceptor[] objs)`
`11`	`11`	`{`
`12`		`- return Register(@this, action, (IEnumerable<ICallInterceptor>)objs);`
	`12`	`+ return @this.Register(action, (IEnumerable<ICallInterceptor>)objs);`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`public static ICallInterceptorRegistry Register<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, IEnumerable<ICallInterceptor> objs)`
`16`	`16`	`{`
`17`		`- return @this.RegisterObjects(action, objs.Cast<object>().ToArray());`
	`17`	`+ return @this.RegisterInterceptors(action, objs.Cast<object>().ToArray());`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`public static ICallInterceptorRegistry Register<TObj, T1>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action)`
`21`	`21`	`where T1: ICallInterceptor, new()`
`22`	`22`	`{`
`23`		`- return @this.RegisterObjects(action, typeof(T1));`
	`23`	`+ return @this.RegisterInterceptors(action, typeof(T1));`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`public static ICallInterceptorRegistry Register<TObj, T1, T2>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action)`
`27`	`27`	`where T1 : ICallInterceptor, new()`
`28`	`28`	`where T2 : ICallInterceptor, new()`
`29`	`29`	`{`
`30`		`- return @this.RegisterObjects(action, typeof(T1), typeof(T2));`
	`30`	`+ return @this.RegisterInterceptors(action, typeof(T1), typeof(T2));`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`public static ICallInterceptorRegistry Register<TObj, T1, T2, T3>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action)`
`34`	`34`	`where T1 : ICallInterceptor, new()`
`35`	`35`	`where T2 : ICallInterceptor, new()`
`36`	`36`	`where T3 : ICallInterceptor, new()`
`37`	`37`	`{`
`38`		`- return @this.RegisterObjects(action, typeof(T1), typeof(T2), typeof(T3));`
	`38`	`+ return @this.RegisterInterceptors(action, typeof(T1), typeof(T2), typeof(T3));`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`public static ICallInterceptorRegistry Register<TObj, T1, T2, T3, T4>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action)`
`@@ -44,42 +44,27 @@ public static ICallInterceptorRegistry Register<TObj, T1, T2, T3, T4>(this ICall`
`44`	`44`	`where T3 : ICallInterceptor, new()`
`45`	`45`	`where T4 : ICallInterceptor, new()`
`46`	`46`	`{`
`47`		`- return @this.RegisterObjects(action, typeof(T1), typeof(T2), typeof(T3), typeof(T4));`
	`47`	`+ return @this.RegisterInterceptors(action, typeof(T1), typeof(T2), typeof(T3), typeof(T4));`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`public static ICallInterceptorRegistry Register<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, Predicate<IActionInvocation> before, Action<IActionReturn> after)`
`51`	`51`	`{`
`52`		`- return @this.RegisterObjects(action, new DelegatedCallInterceptor(before, after));`
`53`		`- }`
`54`		`-`
`55`		`- public static ICallInterceptorRegistry Register<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, Action<IActionInvocation> before)`
`56`		`- {`
`57`		`- return Register(@this, action, x => { before(x); return true; }, null);`
`58`		`- }`
`59`		`-`
`60`		`- public static ICallInterceptorRegistry Register<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, Predicate<IActionInvocation> before)`
`61`		`- {`
`62`		`- return Register(@this, action, before, null);`
`63`		`- }`
`64`		`-`
`65`		`- public static ICallInterceptorRegistry Register<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, Action<IActionReturn> after)`
`66`		`- {`
`67`		`- return Register(@this, action, null, after);`
	`52`	`+ return @this.RegisterInterceptors(action, new DelegatedCallInterceptor(before, after));`
`68`	`53`	`}`
`69`	`54`
`70`	`55`	`public static ICallInterceptorRegistry RegisterBefore<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, Action<IActionInvocation> before)`
`71`	`56`	`{`
`72`		`- return Register(@this, action, x => { before(x); return true; }, null);`
	`57`	`+ return @this.Register(action, x => { before(x); return true; }, null);`
`73`	`58`	`}`
`74`	`59`
`75`	`60`	`public static ICallInterceptorRegistry RegisterBeforeCancellable<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, Predicate<IActionInvocation> before)`
`76`	`61`	`{`
`77`		`- return Register(@this, action, before, null);`
	`62`	`+ return @this.Register(action, before, null);`
`78`	`63`	`}`
`79`	`64`
`80`	`65`	`public static ICallInterceptorRegistry RegisterAfter<TObj>(this ICallInterceptorRegistry @this, Expression<Action<TObj>> action, Action<IActionReturn> after)`
`81`	`66`	`{`
`82`		`- return Register(@this, action, null, after);`
	`67`	`+ return @this.Register(action, null, after);`
`83`	`68`	`}`
`84`	`69`	`}`
`85`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Linq.Expressions;`
	`3`	`+using System.Reflection;`
`3`	`4`	`using MvcExtensions;`
`4`	`5`
`5`	`6`	`namespace MvcInterception`
`@@ -12,6 +13,8 @@ ContainerAdapter Container`
`12`	`13`	`set;`
`13`	`14`	`}`
`14`	`15`
`15`		`- ICallInterceptorRegistry RegisterObjects<TObj>(Expression<Action<TObj>> action, params object[] objs);`
	`16`	`+ ICallInterceptorRegistry RegisterInterceptors<TObj>(Expression<Action<TObj>> action, params object[] objs);`
	`17`	`+`
	`18`	`+ ICallInterceptorRegistry RegisterInterceptors<TObj>(Predicate<MethodBase> methodPred, params object[] objs);`
`16`	`19`	`}`
`17`	`20`	`}`