Interception in .NET

·        Step I: Install package “Microsoft.Practices.Unity” using Package Manager Console.

·        Step II: Unity container by default does not support interception so to add support for interception you must add the Unity interception extension. 

·        Step III: Add the information about type to intercept and behaviors to add.

For the demonstration simplicity, a console application is chosen for example.

1.      Main method:

This includes the hooking up of Unity Container code. A support for interception needs to be added to Unity Container.

This is followed by registration of classes for interception. The methods called from the Main() are also demonstrated here.

// public static void Main(string[] args) {
IUnityContainer container = new UnityContainer();
container.RegisterType<ICalculator, Calculator>();
var calculator = ResolveContainer(container);
Console.WriteLine("/****** " + "No interception as Unity by default does not support interception" + "******/");
Console.WriteLine("/****** " + " Unity's extensions for Interception is not added to container " + "******/");
CallAddMethod(container, calculator);
container = new UnityContainer();
container.AddNewExtension<Interception>(); // To add support for interception.
Console.WriteLine("/****** " + "Interception begins" + "******/");
Console.WriteLine("/****** " + " Unity's extensions for Interception is added to container " + "******/");
container.RegisterType<ICalculator, Calculator>(new InterceptionBehavior<PolicyInjectionBehavior>(),
new Interceptor<InterfaceInterceptor>()); //Register a type mapping with the container
Console.WriteLine("/****** " + "Interface interception" + "******/");
Console.WriteLine("/****** " + " Unity's extensions for Interception is registered for interface interceptor with InterfaceInterceptor" + "******/");
var proxy = ResolveContainer(container);
CallAddMethod(container, proxy);
Console.WriteLine("/****** " + "Virtual Method interception" + "******/");
Console.WriteLine("/****** " + " Unity's extensions for Interception is registered for virtual method with VirtualMethodInterceptor" + "******/");
container.RegisterType<ICalculator,ClassWithVirtualMethodInterception>(new InterceptionBehavior<PolicyInjectionBehavior>(),
new Interceptor<VirtualMethodInterceptor>()); //Register a type mapping with the container
var virtualMethodProxy = ResolveContainer(container);
CallAddMethod(container, virtualMethodProxy);
Console.WriteLine("/****** " + "Transparent Proxy Interception" + "******/");
Console.WriteLine("/****** " + " Unity's extensions for Interception is registered for proxy with TransparentProxyInterceptor" + "******/");
container.RegisterType<IAddition, ClassWithTransparentProxy>(new InterceptionBehavior<PolicyInjectionBehavior>(),
new Interceptor<TransparentProxyInterceptor>()); //Register a type mapping with the container
var transparentProxy = ResolveContainerWithTransparentProxy(container);
CallAddMethodWithTransparentProxyInterception(container, transparentProxy);
Console.ReadKey();
}
private static ICalculator ResolveContainer(IUnityContainer container) {
var calculator = container.Resolve<ICalculator>();
return calculator;
}
private static IAddition ResolveContainerWithTransparentProxy(IUnityContainer container) {
var addition = container.Resolve<IAddition>();
return addition;
}
private static void CallAddMethod(IUnityContainer container, ICalculator calculator) {
Console.WriteLine("/****** " + " Add method is called " + "******/");
Console.WriteLine("/****** " + " Multiply method is called in Add " + "******/");
Console.WriteLine("Outer type: " + calculator.GetType().ToString());
calculator.Add(1, 2);
Console.WriteLine();
}
private static void CallAddMethodWithTransparentProxyInterception(IUnityContainer container, IAddition proxy) {
Console.WriteLine("/****** " + " Add method is called with TransparentProxy Interception " + "******/");
Console.WriteLine("/****** " + " Multiply method is called in Add " + "******/");
Console.WriteLine("Outer type: " + proxy.GetType().ToString());
proxy.Add(3, 4);
((IMultiplication)proxy).Multiply(3, 4);
}

1.       Logger attribute and call handler:

internal class InterceptionLoggerAttribute : HandlerAttribute {
public override ICallHandler CreateHandler(Microsoft.Practices.Unity.IUnityContainer container ) {
  return new InterceptionLoggerCallHandler (); }
}
internal class InterceptionLoggerCallHandler : IcallHandler {
 public IMethodReturn Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext) {
 IMethodReturn result = getNext()(input, getNext);
 if (result.Exception != null)
 {
 Console.WriteLine("Exception occured: " + result.Exception.Message); // logic for logging the exceptions and method  arguments is written
 Console.WriteLine("Parameters:");
 foreach (var parameter in input.Arguments)
 {
 Console.WriteLine(parameter.ToString());
 }
 Console.WriteLine();
 Console.WriteLine("StackTrace:");
 Console.WriteLine(Environment.StackTrace);
 }
return result;
}
public int Order { get; set; }
}

Scenario 1: When there is a need to intercept calls on only one interface, interface interception should be used.  It can intercept both virtual and non- virtual methods.

public interface Icalculator { 
[InterceptionLogger]
 void Add(int number1, int number2);
 [InterceptionLogger]
 void Multiply(int number1, int number2);
}
          class Calculator:Icalculator {
 public virtual void Add(int number1, int number2) {
 int result = number1 + number2;
 Console.WriteLine("In Add method");
 Console.WriteLine("Result of addition:" + result);
 Multiply(2, 4);
}
 public virtual void Multiply(int number1, int number2) {
 int result = number1 * number2;
 Console.WriteLine("In multiply method");
 Console.WriteLine("Result of multiplication:" + result);
}
}
}

Output of interface interception: The output shows that with interface interception only Add() method got intercepted. Multiply() method did not get intercepted as it is called internally

Fig#1

Scenario 2: When the type to intercept is a “MarshalByRefObject” or when only methods from the type's implemented interfaces need to be intercepted. It can intercept both virtual and non-virtual methods. When the methods from more than one interface needs to be intercepted then use transparent proxy interceptor.

public interface Iaddition {
 [InterceptionLogger]
 void Add(int number1, int number2);
}
 public interface Imultiplication {
 [InterceptionLogger]
 void Multiply(int number1, int number2);
}

Here the class implements methods from more than one interface.

class ClassWithTransparentProxy : IAddition,IMultiplication {
public void Add(int number1, int number2) {
int result = number1 + number2;
Console.WriteLine("In Add method");
Console.WriteLine("Result of addition:" + result); }
public void Multiply(int number1, int number2) {
int result = number1 * number2;
Console.WriteLine("In multiply method");
Console.WriteLine("Result of multiplication:" + result);
           }
}

Output of transparent proxy interceptor:

Fig#2

Scenario 3: When virtual methods needs to be intercepted and when you need to intercept internal calls in that class that means when one method in a class invokes another method in the same class then you need to use this interceptor as the internal method will also be intercepted.

public interface ICalculator {
 [InterceptionLogger]
 void Add(int number1, int number2);
 
 [InterceptionLogger]
 void Multiply(int number1, int number2);
}
public class ClassWithVirtualMethodInterception: ICalculator {
public virtual void Add(int number1, int number2) {
int result = number1 + number2;
Console.WriteLine("In Add method");
Console.WriteLine("Result of addition:"+result);
Multiply(2,4); // Internal method also gets intercepted with virtual method interception.
}
public virtual void Multiply(int number1, int number2) {
int result = number1 * number2;
Console.WriteLine("In multiply method");
Console.WriteLine("Result of multiplication:"+result);
}
}

Output of virtual method interception: The output below shows that internal methods also gets intercepted with virtual method interception. The multiply method below is internal method.

Fig#3

Summary and Conclusion

Reference