Interception in .NET – Part 4: An Interception Framework

Introduction

This is the fourth and possibly final post on my interception in .NET series. See the last one here. This time, I’m going to present a framework for doing dynamic interception. Mind you, this is proof of concept code, it is not ready for production usage, although it can do some interesting things! This is going to be a long post, bear with me!

Core Concepts and Types

As I mentioned on the second post, there are essentially four dynamic interception techniques for .NET:

  • Virtual method interception
  • Interface interception
  • Transparent proxy interception
  • Context-bound object interception

I’m going to introduce another one, interception using dynamics, at the end of this post, I think it has some merits of its own.

The interceptors are organized into two groups:

  • Instance interceptors: interface interceptor, dynamic interceptor, context-bound object interceptor, transparent proxy interceptor
  • Type interceptors: virtual method interceptor

An instance interceptor is one that takes an existing object and intercepts calls made to its methods. A type interceptor, on the other hand, generates a type deriving from a given one that, when instantiated, will have the interception hooks that we chose to add to it.

The interception hooks mean that we can intercept a method call – and remember that properties are actually methods – and execute custom code before, after or instead of the intercepted method. An interception hook for an instance interceptor is an instance of a class that implements some interface, and for a type interceptor, it is a type that also implements that specific interface.

Let’s see some basic interfaces, first, the IInterceptor:

public interface IInterceptor
{
}

Not much to it, as you can see, I only use it as the base for both the instance and type interceptor contracts. Next, the IInstanceInterceptor, that is, the contract for an instance interceptor:

public interface IInstanceInterceptor : IInterceptor
{
object Intercept(object instance, Type typeToIntercept, IInterceptionHandler handler);

bool CanIntercept(object instance);
}

Only two methods, nothing too complex:

  • CanIntercept returns true if the instance can be intercepted, by the particular interceptor
  • Intercept receives the instance to intercept, an optional interface type and returns a proxy to the object being intercepted

I would also like to introduce now the IInterceptionHandler interface, which represents our interception hook:

public interface IInterceptionHandler
{
void Invoke(InterceptionArgs arg);
}

Only one method, Invoke, which is called when an interception is under way. Its InterceptionArgs contains the method to be intercepted, the actual instance where the method is being invoked, any method arguments and the desired return value:

[Serializable]
public sealed class InterceptionArgs : EventArgs
{
private object result;

public InterceptionArgs(object instance, MethodInfo method, params object [] arguments)
{
this.Instance = instance;
this.Method = method;
this.Arguments = arguments;
}

public void Proceed()
{
this.Result = this.Method.Invoke(this.Instance, this.Arguments);
}

public object Instance
{
get;
private set;
}

public MethodInfo Method
{
get;
private set;
}

public object [] Arguments
{
get;
private set;
}

public bool Handled
{
get;
set;
}

public object Result
{
get
{
return (this.result);
}
set
{
this.result = value;
this.Handled = true;
}
}
}

Noteworthy:

  • Method is, of course, the method being intercepted, which may well be either the setter or the getter of a property
  • Result will contain the result of the execution, if the intercepted method is not void
  • Arguments are the arguments being passed to the intercepted method
  • Instance is the actual instance on which the method was called
  • Handled is a flag that is set by the IInterceptionHandler’s Invoke method to tell the framework that we intercepted the normal course of the call
  • The Proceed method, if called, will cause the intercepted call to execute as if it hadn’t been intercepted

The ITypeInterceptor type, the contract for type interceptors:

public interface ITypeInterceptor : IInterceptor
{
Type Intercept(Type typeToIntercept, Type interceptionType);

bool CanIntercept(Type typeToIntercept);
}

Pretty similar to IInstanceInterceptor, but:

  • CanIntercept takes a Type instead of an instance
  • Intercept also takes the Type to intercept and the interception type (implementing IInterceptionHandler) and returns another Type, which should be a subclass of the Type to intercept

And, finally, the interface that is going to be implemented by generated (proxified) types, IInterceptionProxy:

public interface IInterceptionProxy
{
IInterceptor Interceptor
{
get;
}
}

Now let’s see how we implement the actual interceptors.

Virtual Method Interceptor

A virtual method interceptor is a type interceptor, it needs to generate dynamically a class that inherits from the passed type and, for all of its virtual methods that are marked for interception, override them in this dynamic class, adding hooks for the interception aspect.

There are basically two APIs in classic .NET for generating code at runtime:

Recently, we have another option: Roslyn. But I won’t talk about it here, definitely a topic for a future series of posts on its own.

For this example, I am going to use CodeDOM. The VirtualMethodInterceptor class looks like this:

public sealed class VirtualMethodInterceptor : ITypeInterceptor
{
private readonly InterceptedTypeGenerator generator;

public VirtualMethodInterceptor(InterceptedTypeGenerator generator)
{
this.generator = generator;
}

public VirtualMethodInterceptor() : this(CodeDOMInterceptedTypeGenerator.Instance)
{

}

private Type CreateType(Type typeToIntercept, Type handlerType)
{
return (this.generator.Generate(this, typeToIntercept, handlerType));
}

public Type Intercept(Type typeToIntercept, Type handlerType)
{
if (typeToIntercept == null)
{
throw (new ArgumentNullException("typeToIntercept"));
}

if (handlerType == null)
{
throw (new ArgumentNullException("handlerType"));
}

if (this.CanIntercept(typeToIntercept) == false)
{
throw (new ArgumentException("typeToIntercept"));
}

if (typeof(IInterceptionHandler).IsAssignableFrom(handlerType) == false)
{
throw (new ArgumentException("handlerType"));
}

if (handlerType.IsPublic == false)
{
throw (new ArgumentException("handlerType"));
}

if ((handlerType.IsAbstract == true) || (handlerType.IsInterface == true))
{
throw (new ArgumentException("handlerType"));
}

if (handlerType.GetConstructor(Type.EmptyTypes) == null)
{
throw (new ArgumentException("handlerType"));
}

return (this.CreateType(typeToIntercept, handlerType));
}

public bool CanIntercept(Type typeToIntercept)
{
return ((typeToIntercept.IsInterface == false) && (typeToIntercept.IsSealed == false));
}
}

The biggest part of the work is done, however, by a type generator. We have a base class for it, InterceptedTypeGenerator:

public abstract class InterceptedTypeGenerator
{
public abstract Type Generate(IInterceptor interceptor, Type baseType, Type handlerType, params Type [] additionalInterfaceTypes);
}

Its contract specifies the base type (that is going to be subclassed), any additional interfaces and an interception handler type, which needs to implement IInterceptionHandler and have a public parameterless constructor.

And here is a concrete implementation using CodeDOM, CodeDOMInterceptedTypeGenerator:

internal class CodeDOMInterceptedTypeGenerator : InterceptedTypeGenerator
{
public static readonly InterceptedTypeGenerator Instance = new CodeDOMInterceptedTypeGenerator();

private static readonly CodeDomProvider provider = new CSharpCodeProvider();
private static readonly CodeGeneratorOptions options = new CodeGeneratorOptions() { BracingStyle = "C" };
private static readonly CodeTypeReference proxyTypeReference = new CodeTypeReference(typeof(IInterceptionProxy));
private static readonly CodeTypeReference interceptorTypeReference = new CodeTypeReference(typeof(IInterceptor));
private static readonly CodeTypeReference handlerTypeReference = new CodeTypeReference(typeof(IInterceptionHandler));
private static readonly Assembly proxyAssembly = typeof(IInterceptionProxy).Assembly;
private static readonly Type interfaceProxyType = typeof(InterfaceProxy);

protected virtual void GenerateConstructors(CodeTypeDeclaration targetClass, Type baseType, IEnumerable<ConstructorInfo> constructors)
{
foreach (var constructor in constructors)
{
var c = new CodeConstructor();
targetClass.Members.Add(c);

c.Attributes = MemberAttributes.Final | MemberAttributes.Override;

foreach (var parameter in constructor.GetParameters())
{
c.Parameters.Add(new CodeParameterDeclarationExpression(parameter.ParameterType, parameter.Name));
}

if (baseType == interfaceProxyType)
{
c.Attributes |= MemberAttributes.Public;
}
else
{
if ((constructor.Attributes & MethodAttributes.Public) == MethodAttributes.Public)
{
c.Attributes |= MemberAttributes.Public;
}
else if ((constructor.Attributes & MethodAttributes.FamORAssem) == MethodAttributes.FamORAssem)
{
c.Attributes |= MemberAttributes.FamilyOrAssembly;
}
else if ((constructor.Attributes & MethodAttributes.Family) == MethodAttributes.Family)
{
c.Attributes |= MemberAttributes.Family;
}
else if ((constructor.Attributes & MethodAttributes.FamANDAssem) == MethodAttributes.FamANDAssem)
{
c.Attributes |= MemberAttributes.FamilyAndAssembly;
}
}

foreach (var p in constructor.GetParameters())
{
c.BaseConstructorArgs.Add(new CodeArgumentReferenceExpression(p.Name));
}
}
}

protected virtual void GenerateMethods(CodeTypeDeclaration targetClass, Type baseType, IEnumerable<MethodInfo> methods)
{
if (methods.Any() == true)
{
var finalizeMethod = methods.First().DeclaringType.GetMethod("Finalize", BindingFlags.NonPublic | BindingFlags.Instance);

foreach (var method in methods)
{
if (method == finalizeMethod)
{
continue;
}

if (method.IsSpecialName == true)
{
continue;
}

var m = new CodeMemberMethod();
m.Name = method.Name;
m.ReturnType = new CodeTypeReference(method.ReturnType);

if (baseType != interfaceProxyType)
{
m.Attributes = MemberAttributes.Override;
}

targetClass.Members.Add(m);

foreach (var parameter in method.GetParameters())
{
m.Parameters.Add(new CodeParameterDeclarationExpression(parameter.ParameterType, parameter.Name));
}

if ((method.Attributes & MethodAttributes.Public) == MethodAttributes.Public)
{
m.Attributes |= MemberAttributes.Public;
}
else if ((method.Attributes & MethodAttributes.FamORAssem) == MethodAttributes.FamORAssem)
{
m.Attributes |= MemberAttributes.FamilyOrAssembly;
}
else if ((method.Attributes & MethodAttributes.Family) == MethodAttributes.Family)
{
m.Attributes |= MemberAttributes.Family;
}
else if ((method.Attributes & MethodAttributes.FamANDAssem) == MethodAttributes.FamANDAssem)
{
m.Attributes |= MemberAttributes.FamilyAndAssembly;
}

if (baseType == interfaceProxyType)
{
m.Attributes = MemberAttributes.Public | MemberAttributes.Final;
}

var currentMethod = new CodeVariableDeclarationStatement(typeof(MethodInfo), "currentMethod", new CodeCastExpression(typeof(MethodInfo), new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(MethodBase)), "GetCurrentMethod"))));
var getType = new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance"), "GetType");
var getMethod = new CodeMethodInvokeExpression(getType, "GetMethod", new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("currentMethod"), "Name"));
var originalMethod = new CodeVariableDeclarationStatement(typeof(MethodInfo), "originalMethod", getMethod);

m.Statements.Add(currentMethod);
m.Statements.Add(originalMethod);

var ps = new CodeExpression[] { new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance"), new CodeVariableReferenceExpression("originalMethod") }.Concat(method.GetParameters().Select(x => new CodeVariableReferenceExpression(x.Name))).ToArray();
var arg = new CodeVariableDeclarationStatement(typeof(InterceptionArgs), "args", new CodeObjectCreateExpression(typeof(InterceptionArgs), ps));

m.Statements.Add(arg);

var handler = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "handler"), "Invoke"), new CodeVariableReferenceExpression("args"));
m.Statements.Add(handler);

var comparison = new CodeBinaryOperatorExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("args"), "Handled"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(method.ReturnType != typeof(void)));
CodeConditionStatement @if = null;

if (method.ReturnType != typeof(void))
{
if (baseType != interfaceProxyType)
{
@if = new CodeConditionStatement(comparison, new CodeMethodReturnStatement(new CodeCastExpression(method.ReturnType, new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("args"), "Result"))));

m.Statements.Add(@if);
m.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), method.Name, method.GetParameters().Select(x => new CodeArgumentReferenceExpression(x.Name)).ToArray())));
}
else
{
@if = new CodeConditionStatement(comparison, new CodeMethodReturnStatement(new CodeCastExpression(method.ReturnType, new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("args"), "Result"))));

m.Statements.Add(@if);
m.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeCastExpression(method.DeclaringType, new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance")), m.Name), method.GetParameters().Select(x => new CodeArgumentReferenceExpression(x.Name)).ToArray())));
}
}
else
{
if (baseType != interfaceProxyType)
{
@if = new CodeConditionStatement(comparison, new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeBaseReferenceExpression(), method.Name, method.GetParameters().Select(x => new CodeArgumentReferenceExpression(x.Name)).ToArray())));

m.Statements.Add(@if);
}
else
{
@if = new CodeConditionStatement(comparison, new CodeMethodReturnStatement(new CodeCastExpression(method.ReturnType, new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("args"), "Result"))));

m.Statements.Add(@if);
m.Statements.Add(new CodeExpressionStatement(new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeCastExpression(method.DeclaringType, new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance")), m.Name), method.GetParameters().Select(x => new CodeArgumentReferenceExpression(x.Name)).ToArray())));
}
}
}
}
}

protected virtual void GenerateProperties(CodeTypeDeclaration targetClass, Type baseType, IEnumerable<PropertyInfo> properties)
{
var interceptorProperty = new CodeMemberProperty();
interceptorProperty.Name = "Interceptor";
interceptorProperty.Type = interceptorTypeReference;
interceptorProperty.Attributes |= MemberAttributes.Private;
interceptorProperty.PrivateImplementationType = proxyTypeReference;
interceptorProperty.GetStatements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "interceptor")));
targetClass.Members.Add(interceptorProperty);

foreach (var property in properties)
{
var p = new CodeMemberProperty();
p.Name = property.Name;
p.Type = new CodeTypeReference(property.PropertyType);

if (baseType != interfaceProxyType)
{
p.Attributes = MemberAttributes.Override;
}

targetClass.Members.Add(p);

if (property.CanRead == true)
{
p.HasGet = true;

if ((property.GetMethod.Attributes & MethodAttributes.Public) == MethodAttributes.Public)
{
p.Attributes |= MemberAttributes.Public;
}
else if ((property.GetMethod.Attributes & MethodAttributes.FamORAssem) == MethodAttributes.FamORAssem)
{
p.Attributes |= MemberAttributes.FamilyOrAssembly;
}
else if ((property.GetMethod.Attributes & MethodAttributes.Family) == MethodAttributes.Family)
{
p.Attributes |= MemberAttributes.Family;
}
else if ((property.GetMethod.Attributes & MethodAttributes.FamANDAssem) == MethodAttributes.FamANDAssem)
{
p.Attributes |= MemberAttributes.FamilyAndAssembly;
}

if (baseType == interfaceProxyType)
{
p.Attributes = MemberAttributes.Public | MemberAttributes.Final;
}

var currentMethod = new CodeVariableDeclarationStatement(typeof(MethodInfo), "currentMethod", new CodeCastExpression(typeof(MethodInfo), new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(MethodBase)), "GetCurrentMethod"))));
var getType = new CodeMethodInvokeExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance"), "GetType");
var getMethod = new CodeMethodInvokeExpression(getType, "GetMethod", new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("currentMethod"), "Name"));
var originalMethod = new CodeVariableDeclarationStatement(typeof(MethodInfo), "originalMethod", getMethod);

p.GetStatements.Add(currentMethod);
p.GetStatements.Add(originalMethod);

var ps = new CodeExpression[] { new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance"), new CodeVariableReferenceExpression("originalMethod") };
var arg = new CodeVariableDeclarationStatement(typeof(InterceptionArgs), "args", new CodeObjectCreateExpression(typeof(InterceptionArgs), ps));

p.GetStatements.Add(arg);

var handler = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "handler"), "Invoke"), new CodeVariableReferenceExpression("args"));
p.GetStatements.Add(handler);

var comparison = new CodeBinaryOperatorExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("args"), "Handled"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(true));
var @if = new CodeConditionStatement(comparison, new CodeMethodReturnStatement(new CodeCastExpression(property.PropertyType, new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("args"), "Result"))));

p.GetStatements.Add(@if);

if (baseType != interfaceProxyType)
{
p.GetStatements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(new CodeBaseReferenceExpression(), property.Name)));
}
else
{
p.GetStatements.Add(new CodeMethodReturnStatement(new CodePropertyReferenceExpression(new CodeCastExpression(property.DeclaringType, new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance")), property.Name)));
}
}

if (property.CanWrite == true)
{
p.HasSet = true;

var ps = new CodeExpression[]
{
new CodeThisReferenceExpression(),
new CodeCastExpression(typeof(MethodInfo), new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(typeof(MethodBase)), "GetCurrentMethod"))),
new CodeVariableReferenceExpression("value")
};

var arg = new CodeVariableDeclarationStatement(typeof(InterceptionArgs), "args", new CodeObjectCreateExpression(typeof(InterceptionArgs), ps));

p.SetStatements.Add(arg);

var handler = new CodeMethodInvokeExpression(new CodeMethodReferenceExpression(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "handler"), "Invoke"), new CodeVariableReferenceExpression("args"));
p.SetStatements.Add(handler);

var comparison = new CodeBinaryOperatorExpression(new CodePropertyReferenceExpression(new CodeVariableReferenceExpression("args"), "Handled"), CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(true));
var @if = new CodeConditionStatement(comparison, new CodeMethodReturnStatement());

p.SetStatements.Add(@if);

if (baseType != interfaceProxyType)
{
p.SetStatements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeBaseReferenceExpression(), property.Name), new CodeVariableReferenceExpression("value")));
}
else
{
p.SetStatements.Add(new CodeAssignStatement(new CodePropertyReferenceExpression(new CodeCastExpression(property.DeclaringType, new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "instance")), property.Name), new CodeVariableReferenceExpression("value")));
}
}
}
}

protected virtual void GenerateFields(CodeTypeDeclaration targetClass, Type baseType, Type handlerType, Type interceptorType)
{
if (handlerType != null)
{
var handlerField = new CodeMemberField();
handlerField.Attributes = MemberAttributes.FamilyOrAssembly;
handlerField.Name = "handler";
handlerField.Type = handlerTypeReference;
handlerField.InitExpression = (handlerType != null) ? new CodeObjectCreateExpression(handlerType) : null;
targetClass.Members.Add(handlerField);
}

var interceptorField = new CodeMemberField();
interceptorField.Attributes = MemberAttributes.FamilyOrAssembly;
interceptorField.Name = "interceptor";
interceptorField.Type = interceptorTypeReference;
interceptorField.InitExpression = (interceptorType != null) ? new CodeObjectCreateExpression(interceptorType) : null;
targetClass.Members.Add(interceptorField);
}

protected virtual void AddReferences(CompilerParameters parameters, Type baseType, Type handlerType, Type interceptorType, Type [] additionalInterfaceTypes)
{
parameters.ReferencedAssemblies.Add(string.Concat(proxyAssembly.GetName().Name, Path.GetExtension(proxyAssembly.CodeBase)));
parameters.ReferencedAssemblies.Add(string.Concat(baseType.Assembly.GetName().Name, Path.GetExtension(baseType.Assembly.CodeBase)));

if (handlerType != null)
{
parameters.ReferencedAssemblies.Add(string.Concat(handlerType.Assembly.GetName().Name, Path.GetExtension(handlerType.Assembly.CodeBase)));
}

if (interceptorType != null)
{
parameters.ReferencedAssemblies.Add(string.Concat(interceptorType.Assembly.GetName().Name, Path.GetExtension(interceptorType.Assembly.CodeBase)));
}

foreach (var additionalInterfaceType in additionalInterfaceTypes)
{
parameters.ReferencedAssemblies.Add(string.Concat(additionalInterfaceType.Assembly.GetName().Name, Path.GetExtension(additionalInterfaceType.Assembly.CodeBase)));
}
}

protected virtual IEnumerable<PropertyInfo> GetProperties(Type baseType, Type[] additionalInterfaceTypes)
{
if (baseType != interfaceProxyType)
{
return (baseType.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Where(x => ((x.CanRead == true) && (x.GetMethod.IsVirtual == true)) || ((x.CanWrite == true) && (x.SetMethod.IsVirtual == true))).Concat(additionalInterfaceTypes.SelectMany(x => x.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Where(y => ((y.CanRead == true) && (y.GetMethod.IsVirtual == true)) || ((y.CanWrite == true) && (y.SetMethod.IsVirtual == true))))).Distinct().ToList());
}
else
{
return (additionalInterfaceTypes.SelectMany(x => x.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Where(y => ((y.CanRead == true) && (y.GetMethod.IsVirtual == true)) || ((y.CanWrite == true) && (y.SetMethod.IsVirtual == true)))).Distinct().ToList());
}
}

protected virtual IEnumerable<MethodInfo> GetMethods(Type baseType, Type [] additionalInterfaceTypes)
{
if (baseType != interfaceProxyType)
{
return (baseType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Where(x => x.IsFinal == false && (x.IsVirtual == true || x.IsAbstract == true)).Concat(additionalInterfaceTypes.SelectMany(x => x.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Where(y => y.IsVirtual == true))).Distinct().ToList());
}
else
{
return (additionalInterfaceTypes.SelectMany(x => x.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).Where(y => y.IsFinal == false && (y.IsVirtual == true || y.IsAbstract == true))).Distinct().ToList());
}
}

protected virtual IEnumerable<ConstructorInfo> GetConstructors(Type baseType)
{
return (baseType.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance));
}

public override Type Generate(IInterceptor interceptor, Type baseType, Type handlerType, params Type[] additionalInterfaceTypes)
{
var properties = this.GetProperties(baseType, additionalInterfaceTypes);
var methods = this.GetMethods(baseType, additionalInterfaceTypes);
var constructors = this.GetConstructors(baseType);

var targetClass = new CodeTypeDeclaration(string.Concat(baseType.Name, "_Dynamic"));
targetClass.IsClass = baseType.IsClass;
targetClass.TypeAttributes = TypeAttributes.Sealed | TypeAttributes.Serializable;
targetClass.BaseTypes.Add((baseType.IsInterface == false) ? baseType : typeof(object));
targetClass.BaseTypes.Add(proxyTypeReference.BaseType);

foreach (var additionalInterfaceType in additionalInterfaceTypes)
{
targetClass.BaseTypes.Add(additionalInterfaceType);
}

var samples = new CodeNamespace(baseType.Namespace);
samples.Imports.Add(new CodeNamespaceImport(typeof(string).Namespace));
samples.Types.Add(targetClass);

var targetUnit = new CodeCompileUnit();
targetUnit.Namespaces.Add(samples);

this.GenerateFields(targetClass, baseType, handlerType, (interceptor != null) ? interceptor.GetType() : null);

this.GenerateConstructors(targetClass, baseType, constructors);

this.GenerateMethods(targetClass, baseType, methods);

this.GenerateProperties(targetClass, baseType, properties);

var builder = new StringBuilder();

using (var sourceWriter = new StringWriter(builder))
{
provider.GenerateCodeFromCompileUnit(targetUnit, sourceWriter, options);
}

var parameters = new CompilerParameters() { GenerateInMemory = true };

this.AddReferences(parameters, baseType, handlerType, (interceptor != null) ? interceptor.GetType() : null, additionalInterfaceTypes);

var results = provider.CompileAssemblyFromDom(parameters, targetUnit);

if (results.Errors.HasErrors == true)
{
throw new InvalidOperationException(string.Join(Environment.NewLine, results.Errors.OfType<object>()));
}

return (results.CompiledAssembly.GetTypes().First());
}
}

Granted, this one is a bit complex, as it needs to generate a whole type dynamically, including constructors to match the base type, overrides for virtual method and properties, and it needs to have them call the interception handler instance. The generated type will also implement the IInterceptionProxy interface, which exposes a Interceptor property, from which you can at runtime access the interceptor. If you are not used to working with the code DOM, have a look at it, you might find it instructive! Winking smile

ClassDiagram1

In the end, here is the code to use it:

public class MyInterceptedType
{
public virtual int Property { get; set; }
public virtual void Method() { /* ... */ }
}

var interceptor = new VirtualMethodInterceptor();
var myProxyType = interceptor.Intercept(type, typeof(MyInterceptionHandler));
var myProxy = Activator.CreateInstance(myProxyType) as MyInterceptedType;
myProxy.Method(); //will get intercepted

The only care that you need to take is to only intercept non-virtual types, with public constructors. Also, the interception handler type must have a public parameterless constructor.

Interface Interception

This one is an instance interceptor. The instance to intercept must implement a given interface. Here is the code of InterfaceInterceptor:

public sealed class InterfaceInterceptor : IInstanceInterceptor
{
private readonly InterceptedTypeGenerator generator;

public InterfaceInterceptor(InterceptedTypeGenerator generator)
{
this.generator = generator;
}

public InterfaceInterceptor() : this(CodeDOMInterceptedTypeGenerator.Instance)
{
}

public object Intercept(object instance, Type typeToIntercept, IInterceptionHandler handler)
{
if (instance == null)
{
throw (new ArgumentNullException("instance"));
}

if (typeToIntercept == null)
{
throw (new ArgumentNullException("typeToIntercept"));
}

if (handler == null)
{
throw (new ArgumentNullException("handler"));
}

if (typeToIntercept.IsInstanceOfType(instance) == false)
{
throw (new ArgumentNullException("instance"));
}

if (typeToIntercept.IsInterface == false)
{
throw (new ArgumentNullException("typeToIntercept"));
}

if (this.CanIntercept(instance) == false)
{
throw (new ArgumentNullException("instance"));
}

var interfaceProxy = this.generator.Generate(this, typeof(InterfaceProxy), null, typeToIntercept);

var newInstance = Activator.CreateInstance(interfaceProxy, this, handler, instance);

return (newInstance);
}

public bool CanIntercept(object instance)
{
return (instance.GetType().GetInterfaces().Length != 0);
}
}

You can see that it also needs to generate code at runtime, therefore it uses the same types InterceptedTypeGenerator and CodeDOMInterceptedTypeGenerator shown earlier. This time, the generated proxy implements the interface to intercept and is a subclass of InterfaceProxy:

public abstract class InterfaceProxy
{
protected readonly object instance;
protected readonly IInterceptor interceptor;
protected readonly IInterceptionHandler handler;

protected InterfaceProxy(IInterceptor interceptor, IInterceptionHandler handler, object instance)
{
this.instance = instance;
this.interceptor = interceptor;
this.handler = handler;
}
}

We use it like this:

public interface IMyInterceptedType
{
int Property { get; set; }
void Method();
}

public class MyInterceptedType : IMyInterceptedType
{
public int Property { get; set; }
public void Method() { /* ... */ }
}

var instance = new MyInterceptedType();
var interceptor = new InterfaceInterceptor();
var myProxy = interceptor.Intercept(instance, typeof(IMyInterceptedType), new MyInterceptionHandler()) as IMyInterceptedType;
myProxy.Method(); //will get intercepted

As you can see, all the intercepted type needs is to implement one interface, it’s this interface that can actually be intercepted, and this is the second parameter to the https://msdn.microsoft.com/en-us/library/ms731082(v=vs.110).aspxmethod.

ClassDiagram2

Transparent Proxy Interceptor

This one is the technique that WCF and .NET Remoting use to communicate to a remote system.

The TransparentProxyInterceptor is an instance interceptor:

public sealed class TransparentProxyInterceptor : IInstanceInterceptor
{
public static readonly IInstanceInterceptor Instance = new TransparentProxyInterceptor();

public object Intercept(object instance, Type typeToIntercept, IInterceptionHandler handler)
{
if (instance == null)
{
throw (new ArgumentNullException("instance"));
}

if (typeToIntercept == null)
{
throw (new ArgumentNullException("typeToIntercept"));
}

if (handler == null)
{
throw (new ArgumentNullException("handler"));
}

if (this.CanIntercept(instance) == false)
{
throw (new ArgumentException("instance"));
}

if (typeToIntercept.IsInstanceOfType(instance) == false)
{
throw (new ArgumentException("typeToIntercept"));
}

var proxy = new TransparentProxy(this, instance, typeToIntercept, handler);

return (proxy.GetTransparentProxy());
}

public bool CanIntercept(object instance)
{
return ((instance is MarshalByRefObject) || (instance.GetType().GetInterfaces().Length != 0));
}
}

Here, we don’t generate any code, we just leverage MarshalByRefObject and RealProxy, which do all the magic. We need a type that extends RealProxy and adds our own IInterceptionProxy:

internal sealed class TransparentProxy : RealProxy, IRemotingTypeInfo, IInterceptionProxy
{
private readonly object instance;
private readonly IInterceptionHandler handler;
private readonly TransparentProxyInterceptor interceptor;

public TransparentProxy(TransparentProxyInterceptor interceptor, object instance, Type typeToIntercept, IInterceptionHandler handler) : base(typeToIntercept)
{
this.instance = instance;
this.handler = handler;
this.interceptor = interceptor;
}

public override IMessage Invoke(IMessage msg)
{
ReturnMessage responseMessage;
object response = null;
Exception caughtException = null;

try
{
var methodName = msg.Properties["__MethodName"] as string;
var parameterTypes = msg.Properties["__MethodSignature"] as Type[];
var parameters = msg.Properties["__Args"] as object[];
var typeName = msg.Properties["__TypeName"] as string;
var method = this.instance.GetType().GetMethod(methodName, parameterTypes);

if (method == null)
{
if (methodName.StartsWith("get_") == true)
{
var property = this.instance.GetType().GetProperty(methodName.Substring(4), BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

if (property != null)
{
method = property.GetGetMethod();
}
else
{
if ((methodName == "get_Interceptor") && (typeName == typeof(IInterceptionProxy).AssemblyQualifiedName))
{
return (new ReturnMessage(this.interceptor, null, 0, null, msg as IMethodCallMessage));
}
}
}
}

var args = new InterceptionArgs(this.instance, method, parameters);

this.handler.Invoke(args);

if (args.Handled == false)
{
args.Proceed();
}

response = args.Result;
}
catch (Exception ex)
{
caughtException = ex;
}

var message = msg as IMethodCallMessage;

if (caughtException == null)
{
responseMessage = new ReturnMessage(response, null, 0, null, message);
}
else
{
responseMessage = new ReturnMessage(caughtException, message);
}

return (responseMessage);
}

bool IRemotingTypeInfo.CanCastTo(Type fromType, object o)
{
return (fromType == typeof(IInterceptionProxy));
}

string IRemotingTypeInfo.TypeName
{
get;
set;
}

public IInterceptor Interceptor
{
get { return this.interceptor; }
}
}

Using TransparentProxyInterceptor we can only intercept types that either inherit from MarshalByRefObject or implement some interface, in which case, we can only intercept methods and properties coming from that interface.

Here’s how we would use it with any type (not inheriting from MarshalByRefObject) that exposes an interface:

public interface IMyInterceptedType
{
int Property { get; set; }
void Method();
}

public class MyInterceptedType : IMyInterceptedType
{
public int Property { get; set; }
public void Method() { /* ... */ }
}

var instance = new MyInterceptedType();
var interceptor = new TransparentProxyInterceptor();
var canIntercept = interceptor.CanIntercept(instance);
var myProxy = interceptor.Intercept(instance, typeof(IMyInterceptedType), new MyInterceptionHandler()) as IMyInterceptedType;
var proxy = myProxy as IInterceptionProxy;
var otherInterceptor = proxy.Interceptor;
myProxy.Method(); //will get intercepted

Again, all it takes is an interface to intercept.

Context Bound Object Interceptor

Since its early days, .NET introduced an interception mechanism that doesn’t need any coding. The problem is that it requires inheriting from a particular base class (ContextBoundObject) plus adding an attribute to it (ContextAttribute). I include this technique here for completeness, since it is usually not that useful.

The ContextBoundInterceptor looks like this:

public sealed class ContextBoundObjectInterceptor : IInstanceInterceptor
{
public static readonly IInstanceInterceptor Instance = new ContextBoundObjectInterceptor();

internal static readonly ConcurrentDictionary<ContextBoundObject, IInterceptionHandler> interceptors = new ConcurrentDictionary<ContextBoundObject, IInterceptionHandler>();

public object Intercept(object instance, Type typeToIntercept, IInterceptionHandler handler)
{
if (!(instance is ContextBoundObject))
{
throw new ArgumentException("Instance is not a ContextBoundObject.", "instance");
}

interceptors[instance as ContextBoundObject] = handler;

return (instance);
}

public bool CanIntercept(object instance)
{
return ((instance is ContextBoundObject) && (Attribute.IsDefined(instance.GetType(), typeof(InterceptionContextAttribute))));
}

public static IInterceptionHandler GetInterceptor(ContextBoundObject instance)
{
foreach (var @int in interceptors)
{
if (@int.Key == instance)
{
return @int.Value;
}
}

return null;
}
}

We need to use a trick here to associate an interceptor with an intercepted instance, in the form of a static dictionary. In order to make this work, we also need the InterceptionContextAttribute:

[Serializable]
[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
public sealed class InterceptionContextAttribute : ContextAttribute
{
public InterceptionContextAttribute() : base("InterceptionContext")
{
}

public override void GetPropertiesForNewContext(IConstructionCallMessage ctorMsg)
{
ctorMsg.ContextProperties.Add(new InterceptionProperty());
base.GetPropertiesForNewContext(ctorMsg);
}

public override bool IsContextOK(Context ctx, IConstructionCallMessage ctorMsg)
{
var p = ctx.GetProperty(InterceptionProperty.InterceptionPropertyName) as InterceptionProperty;
return (p != null);
}

public override bool IsNewContextOK(Context newCtx)
{
var p = newCtx.GetProperty(InterceptionProperty.InterceptionPropertyName) as InterceptionProperty;
return (p != null);
}
}

And the InterceptionProperty:

internal sealed class InterceptionProperty : IContextProperty, IContributeObjectSink
{
internal static readonly string InterceptionPropertyName = "Interception";

public string Name
{
get
{
return InterceptionPropertyName;
}
}

public bool IsNewContextOK(Context newCtx)
{
var p = newCtx.GetProperty(this.Name) as InterceptionProperty;
return p != null;
}

public void Freeze(Context newContext)
{
}

public IMessageSink GetObjectSink(MarshalByRefObject obj, IMessageSink nextSink)
{
return new InterceptionMessageSink(obj as ContextBoundObject, nextSink);
}
}

Much more work that it deserves, I’d say. Anyway, here’s a sample usage:

public interface IMyInterceptedType
{
int Property { get; set; }
void Method();
}

[InterceptionContext]
public class MyInterceptedType : ContextBoundObject, IMyInterceptedType
{
public int Property { get; set; }
public void Method() { /* ... */ }
}

var instance = new MyInterceptedType();
var interceptor = new ContextBoundObjectInterceptor();
var myProxy = interceptor.Intercept(instance, null, new MyInterceptionHandler()) as IMyInterceptedType;
myProxy.Method(); //will get intercepted

As I said, this technique is only listed here for completeness’ sake, I don’t expect you to be using it much.

Dynamic Interceptor

Final technique, this time, we will be making use of the dynamic functionality introduced in .NET 4.

First, the DynamicInterceptor class, another instance interceptor:

public sealed class DynamicInterceptor : IInstanceInterceptor
{
public static readonly IInstanceInterceptor Instance = new DynamicInterceptor();

public object Intercept(object instance, Type typeToIntercept, IInterceptionHandler handler)
{
return new DynamicProxy(this, instance, handler);
}

public bool CanIntercept(object instance)
{
return true;
}
}

Simple, right? And here is the DynamicProxy:

internal sealed class DynamicProxy : DynamicObject, IInterceptionProxy
{
private readonly IInterceptionHandler handler;
private readonly object target;

public DynamicProxy(IInterceptor interceptor, object target, IInterceptionHandler handler)
{
if (interceptor == null)
{
throw new ArgumentNullException("target");
}

if (target == null)
{
throw new ArgumentNullException("target");
}

if (handler == null)
{
throw new ArgumentNullException("handler");
}

this.Interceptor = interceptor;
this.target = target;
this.handler = handler;
}

public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
{
var method = this.target.GetType().GetMethod(binder.Name);
var arg = new InterceptionArgs(this.target, method, args);

this.handler.Invoke(arg);

if (arg.Handled == true)
{
result = arg.Result;
}
else
{
result = method.Invoke(this.target, args);
}

return true;
}

public IInterceptor Interceptor { get; private set; }
}

This one inherits from DynamicObject, which allows us to find properties and methods at runtime.

Finally, its usage:

public class MyInterceptedType
{
public int Property { get; set; }
public void Method() { /* ... */ }
}

var instance = new MyInterceptedType();
var interceptor = new DynamicInterceptor();
//here: using dynamic instead of MyInterceptedType!
dynamic myProxy = interceptor.Intercept(instance, null, new MyInterceptionHandler());
myProxy.Method(); //will get intercepted

No constraints whatsoever in what you can intercept, you need only to remember to declare your proxy as dynamic instead of an actual type.

Interception Handlers

Looks cool, right? What about interception handlers – the parameter that you pass to one of the Intercept methods? Well, it is agnostic as to what interception technique you use and just needs to implement IInterceptionHandler. Its Invoke method is called with a parameter that contains all the information that you need. From there you can do some stuff before calling letting the normal flow proceed, change the arguments to the intercepted method, change the return value (in the case of non-void intercepted methods), do stuff after calling the intercepted method or not call it at all:

public void Invoke(InterceptionArgs arg)
{
arg.Parameters[1] = 120; //changed the original parameters

Console.WriteLine("Before execution");

arg.Proceed(); //call the intercepted method

Console.WriteLine("After execution");

arg.Result = "some result"; //changed the return value

arg.Handled = true; //signal to other interceptors that it has been handled
}

Here is a simple implementation that retries a method call a couple of times in case it throws an exception:

public sealed class RetriesInterceptionHandler : IInterceptionHandler
{
public RetriesInterceptionHandler()
{
this.Retries = 3;
this.Delay = TimeSpan.FromSeconds(5);
}

public int Retries { get; set; }
public TimeSpan Delay { get; set; }

public void Invoke(InterceptionArgs arg)
{
for (var i = 0; i < this.Retries; i++)
{
try
{
arg.Proceed();
break;
}
catch
{
if (i != this.Retries - 1)
{
Thread.Sleep(this.Delay);
}
else
{
throw;
}
}
}
}
}

When it is asked to intercept a method call it loops a number of times, tries to call the default implementation, and, in the event of an exception, sleeps for a while and tries again. If it reached the maximum number of retries, it just throws the caught exception.

Another common scenario is to use attributes as Aspects. We just need to implement an interception handler that looks at interception attributes:

public sealed class AttributesInterceptionHandler : IInterceptionHandler
{
public static readonly IInterceptionHandler Instance = new AttributesInterceptionHandler();

public void Invoke(InterceptionArgs arg)
{
var attrs = arg.Method.GetCustomAttributes(true).OfType<InterceptionAttribute>().OrderBy(x => x.Order).Cast<IInterceptionHandler>();

foreach (var attr in attrs)
{
attr.Invoke(arg);
}
}
}

Where an InterceptionAttribute base class could be implemented as this:

[Serializable]
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = true, Inherited = true)]
public abstract class InterceptionAttribute : Attribute, IInterceptionHandler
{
public int Order { get; set; }

public abstract void Invoke(InterceptionArgs arg);
}

You can specify an order by which you want interception attributes to execute.

Yet another technique, using a registry to associate the methods to intercept with their desired handler:

public sealed class RegistryInterceptionHandler : IInterceptionHandler
{
private readonly Dictionary<MethodInfo, IInterceptionHandler> handlers = new Dictionary<MethodInfo, IInterceptionHandler>();

public RegistryInterceptionHandler Register(Type type, string methodName, IInterceptionHandler handler)
{
foreach (var method in type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public))
{
this.Register(method, handler);
}

return this;
}

public RegistryInterceptionHandler Register(MethodInfo method, IInterceptionHandler handler)
{
if (method == null)
{
throw new ArgumentNullException("method");
}

if (handler == null)
{
throw new ArgumentNullException("handler");
}

this.handlers[method] = handler;

return this;
}

private RegistryInterceptionHandler RegisterExpressionMethod(Expression expression, IInterceptionHandler handler)
{
if (expression is MethodCallExpression)
{
return this.Register((expression as MethodCallExpression).Method, handler);
}
else if (expression is UnaryExpression)
{
if ((expression as UnaryExpression).Operand is MethodCallExpression)
{
return this.Register(((expression as UnaryExpression).Operand as MethodCallExpression).Method, handler);
}
}
else if (expression is MemberExpression)
{
if ((expression as MemberExpression).Member is PropertyInfo)
{
this.Register(((expression as MemberExpression).Member as PropertyInfo).GetMethod, handler);
return this.Register(((expression as MemberExpression).Member as PropertyInfo).SetMethod, handler);
}
}

throw new ArgumentException("Expression is not a method call", "method");
}

public RegistryInterceptionHandler Register<T>(Expression<Func<T, object>> method, IInterceptionHandler handler)
{
return this.RegisterExpressionMethod(method.Body, handler);
}

public RegistryInterceptionHandler Register<T>(Expression<Action<T>> method, IInterceptionHandler handler)
{
return this.RegisterExpressionMethod(method.Body, handler);
}

public void Invoke(InterceptionArgs arg)
{
IInterceptionHandler handler;

if (this.handlers.TryGetValue(arg.Method, out handler) == true)
{
handler.Invoke(arg);
}
}
}

Here you would have to explicitly register the methods you want to intercept (also works for properties), and, for each of these methods, its interception handler:

var registry = new RegistryInterceptionHandler();
registry.Register<IMyInterceptedType>(x => x.Method(), new MyInterceptionHandler());

All you need to do is implement Invoke, and off you go! To make it clear, any of these three implementations – RetriesInterceptionHandlerAttributesInterceptionHandler and RegistryInterceptionHandler – should be passed as the third argument to IInstanceInterceptor.Intercept:

var instance = new MyInterceptedType();
var interceptor = new InterfaceInterceptor();
var proxy = interceptor.Intercept(instance, typeof(IMyInterceptedType), new RetriesInterceptionHandler { Retries = 3, Delay = TimeSpan.FromSeconds(5) }) as IMyInterceptedType;

Conclusion

DevelopmentWithADot.Interception

I’ve shown some techniques that can be used to intercept .NET code in a number of scenarios. You basically need to pick your interceptor based on what you’ve got:

  • If you want to intercept a type (not an instance) that is not sealed or is abstract, you need to use VirtualMethodInterceptor, as it is the only type interceptor
  • If you want to intercept a particular interface, you can use one of InterfaceInterceptor, TransparentProxyInterceptor or DynamicInterceptor
  • If you want to intercept an instance of a class inheriting directly or indirectly from MarshalByRefObject, regardless of whether or not it implements some interface, you can use TransparentProxyInterceptor
  • If you want to intercept some type, whatever its base class or implemented interfaces are, and you are cool with using the dynamic keyword around it, use DynamicInterceptor
  • If you are OK with having a base class of ContextBoundObject, and you also don’t mind adding an obscure attribute to your class, you have ContextBoundObjectInterceptor 

Other scenarios, like intercepting static methods, can only be solved through IL weaving. Have a look at my previous post about it and see if it helps you.

Keep in mind that this code works as it should but it is not bulletproof. Let me know if you face any problems using it, or if you have any questions or remarks!

Unity, Part 11: Integrating With Azure Application Insights

Another one for the Unity series.

Lately I’ve been playing with Azure Application Insights. Nice thing, even if – at least, for the moment – not as powerful as some of its contesters. A thing that came to my mind almost immediately was how to integrate it with IoC containers like Unity.

I already talked about how to use AOP techniques in Unity. This time I will leverage on that and explain how we can use this knowledge to add insights into our application transparently.

We need the Application Insights SDK, which is available at GitHub in source code and conveniently as a NuGet package (all you need is Microsoft.ApplicationInsights):

image

I implemented an HandlerAttribute that is also an implementation of ICallHandler. Inside of it, I call the intercepted method and then log it to Application Insights through the TelemetryClient, a part of the Application Insights APIs. I added an option to set the instrumentation key, which uniquely identifies our Application Insights account and shouldn’t be shared. If not supplied, it will default to whatever is in

TelemetryConfiguration.Active.InstrumentationKey. Finally, we can decide to have the call asynchronous (so as to not cause delays to our application) or synchronous.

Here is the code for the interception attribute:

[Serializable]

[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]

public sealed class TelemetryCallHandlerAttribute : HandlerAttribute, ICallHandler

{

    #region Public constructors

    public TelemetryCallHandlerAttribute()

    {

    }

 

    public TelemetryCallHandlerAttribute(string instrumentationKey)

    {

        this.InstrumentationKey = instrumentationKey;

    }

 

    public string InstrumentationKey { get; set; }

 

    public bool Async { get; set; }

 

    #endregion

 

    #region Public override methods

    public override ICallHandler CreateHandler(IUnityContainer ignored)

    {

        return (this);

    }

    #endregion

 

    #region ICallHandler Members

 

    IMethodReturn ICallHandler.Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)

    {

        TelemetryConfiguration config = null;

 

        if (string.IsNullOrWhiteSpace(this.InstrumentationKey) == true)

        {

            config = TelemetryConfiguration.Active;

        }

        else

        {

            config = TelemetryConfiguration.CreateDefault();

            config.InstrumentationKey = this.InstrumentationKey;

        }

 

        var telemetryClient = new TelemetryClient(config);

        var watch = Stopwatch.StartNew();

        var result = getNext()(input, getNext);

 

        var elapsedMilliseconds = watch.ElapsedMilliseconds;

        var exception = result.Exception;

        var returnValue = result.ReturnValue;

 

        var properties = new Dictionary<string, string>();

 

        for (var i = 0; i < input.Arguments.Count; ++i)

        {

            var key = input.Arguments.ParameterName(i);

            properties[key] = (input.Arguments[i] ?? string.Empty).ToString();

        }

 

        if (exception != null)

        {

            properties["$Exception"] = exception.Message;

        }

 

        if (returnValue != null)

        {

            properties["$ReturnValue"] = returnValue.ToString();

        }

 

        var metrics = new Dictionary<string, double>();

        metrics["ElapsedMilliseconds"] = elapsedMilliseconds;

 

        if (this.Async == false)

        {

            this.TrackEvent(telemetryClient, input.MethodBase.Name, properties, metrics);

        }

        else

        {

            this.TrackEventAsync(telemetryClient, input.MethodBase.Name, properties, metrics);

        }

 

        return (result);

    }

 

    private void TrackEvent(TelemetryClient telemetryClient, string name, IDictionary<string, string> properties, IDictionary<string, double> metrics)

    {

        telemetryClient.TrackEvent(name, properties, metrics);

    }

 

    private async void TrackEventAsync(TelemetryClient telemetryClient, string name, IDictionary<string, string> properties, IDictionary<string, double> metrics)

    {[Serializable]

    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]

    public sealed class TelemetryCallHandlerAttribute : HandlerAttribute, ICallHandler

    {

        #region Public constructors

        public TelemetryCallHandlerAttribute()

        {

        }

 

        public TelemetryCallHandlerAttribute(string instrumentationKey)

        {

            this.InstrumentationKey = instrumentationKey;

        }

 

        public string InstrumentationKey { get; set; }

 

        public bool Async { get; set; }

 

        #endregion

 

        #region Public override methods

        public override ICallHandler CreateHandler(IUnityContainer ignored)

        {

            return (this);

        }

        #endregion

 

        #region ICallHandler Members

 

        IMethodReturn ICallHandler.Invoke(IMethodInvocation input, GetNextHandlerDelegate getNext)

        {

            TelemetryConfiguration config = null;

 

            if (string.IsNullOrWhiteSpace(this.InstrumentationKey) == true)

            {

                config = TelemetryConfiguration.Active;

            }

            else

            {

                config = TelemetryConfiguration.CreateDefault();

                config.InstrumentationKey = this.InstrumentationKey;

            }

 

            var telemetryClient = new TelemetryClient(config);

            var watch = Stopwatch.StartNew();

            var result = getNext()(input, getNext);

 

            var elapsedMilliseconds = watch.ElapsedMilliseconds;

            var exception = result.Exception;

            var returnValue = result.ReturnValue;

 

            var properties = new Dictionary<string, string>();

 

            for (var i = 0; i < input.Arguments.Count; ++i)

            {

                var key = input.Arguments.ParameterName(i);

                properties[key] = (input.Arguments[i] ?? string.Empty).ToString();

            }

 

            if (returnValue != null)

            {

                properties["$ReturnValue"] = returnValue.ToString();

            }

 

            var metrics = new Dictionary<string, double>();

            metrics["ElapsedMilliseconds"] = elapsedMilliseconds;

 

            if (this.Async == false)

            {

                if (exception != null)

                {

                    properties["Name"] = input.MethodBase.Name;

                    this.TrackException(telemetryClient, exception, properties, metrics);

                }

                else

                {

                    this.TrackEvent(telemetryClient, input.MethodBase.Name, properties, metrics);

                }

            }

            else

            {

                if (exception != null)

                {

                    properties["Name"] = input.MethodBase.Name;

                    this.TrackExceptionAsync(telemetryClient, exception, properties, metrics);

                }

                else

                {

                    this.TrackEventAsync(telemetryClient, input.MethodBase.Name, properties, metrics);

                }

            }

 

            return (result);

        }

 

        private void TrackException(TelemetryClient telemetryClient, Exception ex, IDictionary<string, string> properties, IDictionary<string, double> metrics)

        {

            telemetryClient.TrackException(ex, properties, metrics);

        }

 

        private async void TrackExceptionAsync(TelemetryClient telemetryClient, Exception ex, IDictionary<string, string> properties, IDictionary<string, double> metrics)

        {

            await Task.Run(() => this.TrackException(telemetryClient, ex, properties, metrics));

        }

 

        private void TrackEvent(TelemetryClient telemetryClient, string name, IDictionary<string, string> properties, IDictionary<string, double> metrics)

        {

            telemetryClient.TrackEvent(name, properties, metrics);

        }

 

        private async void TrackEventAsync(TelemetryClient telemetryClient, string name, IDictionary<string, string> properties, IDictionary<string, double> metrics)

        {

            await Task.Run(() => this.TrackEvent(telemetryClient, name, properties, metrics));

        }

 

        #endregion

    }        await Task.Run(() => this.TrackEvent(telemetryClient, name, properties, metrics));

    }

 

    #endregion

}

It will track the event under the called method name, and will send along a string representation of all its arguments, result value, exception thrown (if any) and elapsed time (TelemetryClient.TrackEvent or TelemetryClient.TrackException).

A simple usage, without providing the instrumentation key, would be:

[TelemetryCallHandler]

public virtual BusinessResponse PerformBusinessOperation(int businessId, string arg)

{

    //...

}

If the InstrumentationKey property is not supplied, it must be set through TelemetryConfiguration.Active.InstrumentationKey:

TelemetryConfiguration.Active.InstrumentationKey = "my key";

Having it as an IInterceptionBehavior should be straightforward. Feel free to modify it to your liking!

Interception in .NET – Part 2: Dynamic Interception

This is part two of a series of posts on interception in .NET. You can find the first part here.

Interception Targets

There are two possible targets for interception:

  • Types, such as classes or interfaces;
  • Instances of types.

Depending on the target, we can use different interception techniques.

Interception Techniques

In .NET, like in other OOP languages, we have the following interception techniques:

  • Virtual method interception: this is a type interception technique by which we subclass dynamically a target type – an interface or a class, since structures do not allow subclassing – and add method overrides for the methods we want to intercept. Of course, only virtual methods can be intercepted (abstract methods and interface methods are treated as virtual); the interceptor returns an instance of the dynamically generated subclass of the target type, which is treated exactly as if it were this target type;
  • Interface interception: an instance interception technique. There has to be an existing object for us to intercept, and it must implement one or more interfaces. We can intercept any method or property exposed by one of these interfaces; basically, the generated interceptor code sits between the exposed interface and the existing target;
  • Transparent proxy interception: another instance interception technique. The target types must either be interfaces or classes inheriting from MarshalByRefObject, one instance of which should exist. It is possible to intercept any interface methods or any method declared in the MarshalByRefObject-derived class; the interceptor acts as a proxy between the exposed interface or class and the actual object;
  • Context-bound object interception: this a .NET-specific interception technique for instance interception by which we can intercept any calls to objects of classes inheriting from ContextBoundObject. This one is not as generic as the others because we need to have our class inherit from ContextBoundObject, which we wouldn’t normally do, and add some boilerplate code.

Next

Next post will talk about static interception.

Interception in .NET – Part 1: Introduction

Update: see part two here.

Interception is the capability by which developers can inject behavior dynamically into existing methods or properties, before, after or instead of their execution. A common paradigm is Aspect-Oriented Programming (AOP), which postulates that we separate non-core, like cross-cutting concerns, from core functionality, and we apply these concerns automatically to our code; this way developers need only focus on implementing the business requirements. These cross-cutting concerns normally consist of logging, exception handling, caching, access control and the likes. An example: imagine you want any exception that might be thrown by your code to be logged somewhere; in this case, you can create an aspect to be applied to your methods that wraps each in a trycatch block and does something with the caught exception.

In .NET, as in other object-oriented languages (think Java), we have basically two kinds of interception:

  • Static: the assembly code is changed after it is built, a process called IL weaving;
  • Dynamic: changes are done as the application is running.

Some examples of dynamic frameworks that allow injecting interception at compile or runtime include Unity, Ninject, Spring.NET, Castle Windsor, LinFu, Autofac, LOOM.NET, Seasar, etc (as you can see, these are all Inversion of Control containers). Static (post-compilation) ones include Fody, SheepAspect, Mono.Cecil, and PostSharp. There are use cases for both kinds, so one does not really exclude the other. Static interception will probably be faster, but then the resulting assembly will not be exactly what you expect it to be – it has happened to me: the .PDB file would not match the .DLL, but it was my fault! Smile. In dynamic interception you get more control over the process and can even modify it at runtime.

How exactly aspects are applied to the code depends on the framework being used: some rely on attributes, others XML configuration, and others on fluent interfaces. In any case, the general idea is:

“For methods X, Y and Z, before/after/instead of actually executing it, do this instead”

On the next post, I am going to talk about the alternatives that exist for dynamic interception in .NET. Stay tuned!