Creating a dynamic proxy generator – Part 1 – Creating
the Assembly builder, Module builder and caching mechanism
For
the latest code go to http://rapidioc.codeplex.com/
Before getting too involved in generating
the proxy, I thought it would be worth while going through
the intended design, this is important as
the next step is to start creating
the constructors for
the proxy.
Each proxy derives from a specified type
The proxy has a corresponding constructor for each of
the base type constructors
The proxy has overrides for all methods and properties marked as Virtual on
the base type
For each overridden method, there is also a private method whose sole job is to call
the base method.
For each overridden method, a delegate is created whose sole job is to call
the private method that calls
the base method.
The following class diagram shows
the main classes and interfaces involved in
the interception process.
I’ll go through each of them to explain their place in
the overall proxy.
IProxy Interface
The proxy implements
the IProxy interface for
the sole purpose of adding custom interceptors.
This allows
the created proxy interface to be cast as an IProxy and then simply add Interceptors by calling it’s AddInterceptor method.
This is done internally
within the proxy building process so
the consumer of
the API doesn’t need knowledge of this.
IInterceptor Interface
The IInterceptor interface has one method: Handle.
The handle method accepts a IMethodInvocation parameter which contains methods and data for handling method interception.
Multiple classes that implement this interface can be added to
the proxy.
Each method override in
the proxy calls
the handle method rather than simply calling
the base method.
How
the proxy fully works will be explained in
the next section MethodInvocation.
IMethodInvocation Interface & MethodInvocation class
The MethodInvocation will contain one main method and multiple helper properties.
Continue Method
The method Continue() has two functions hidden away from
the consumer.
When Continue is called, if there are multiple Interceptors,
the next Interceptors Handle method is called.
If all Interceptors Handle methods have been called,
the Continue method then calls
the base class method.
Properties
The MethodInvocation will contain multiple helper properties including at least
the following:
Method Name (Read Only)
Method Arguments (Read and Write)
Method Argument Types (Read Only)
Method Result (Read and Write) – this property remains null if
the method return type is void
Target Object (Read Only)
Return Type (Read Only)
DefaultInterceptor class
The DefaultInterceptor class is a simple class that implements
the IInterceptor interface.
Here is
the code:
DefaultInterceptor
namespace Rapid.DynamicProxy.Interception
{
/// <summary>
/// Default interceptor for
the proxy.
/// </summary>
/// <typeparam name="TBase">The base type.</typeparam>
public class DefaultInterceptor<TBase> : IInterceptor<TBase> where TBase : class
{
/// <summary>
/// Handles
the specified method invocation.
/// </summary>
/// <param name="methodInvocation">The method invocation.</param>
public void Handle(IMethodInvocation<TBase> methodInvocation)
{
methodInvocation.Continue();
}
}
}
This is automatically created in
the proxy and is
the first interceptor that each method override calls.
It’s sole function is to ensure that if no interceptors have been added,
the base method is still called.
Custom Interceptor Example
A consumer of
the Rapid.DynamicProxy API could create an interceptor for logging when
the FirstName property of
the User class is set.
Just for illustration, I have also wrapped a transaction around
the methodInvocation.Coninue() method.
This means that any overriden methods
within the user class will run
within a transaction scope.
MyInterceptor
public class MyInterceptor : IInterceptor<User<int, IRepository>>
{
public void Handle(IMethodInvocation<User<int, IRepository>> methodInvocation)
{
if (methodInvocation.Name == "set_FirstName")
{
Logger.Log("First name seting to: " + methodInvocation.Arguments[0]);
}
using (TransactionScope scope = new TransactionScope())
{
methodInvocation.Continue();
}
if (methodInvocation.Name == "set_FirstName")
{
Logger.Log("First name has been set to: " + methodInvocation.Arguments[0]);
}
}
}
Overridden Method Example
To show a taster of what
the overridden methods on
the proxy would look like,
the setter method for
the property FirstName used in
the above example would look something similar to
the following (this is not real code but will look similar):
set_FirstName
public override void set_FirstName(string value)
{
set_FirstNameBaseMethodDelegate callBase =
new set_FirstNameBaseMethodDelegate(this.set_FirstNameProxyGetBaseMethod);
object[] arguments = new object[] { value };
IMethodInvocation<User<IRepository>> methodInvocation =
new MethodInvocation<User<IRepository>>(this, callBase, "set_FirstName", arguments, interceptors);
this.Interceptors[0].Handle(methodInvocation);
}
As you can see, a delegate instance is created which calls to a private method on
the class,
the private method calls
the base method and would look like
the following:
calls base setter
private void set_FirstNameProxyGetBaseMethod(string value)
{
base.set_FirstName(value);
}
The delegate is invoked when methodInvocation.Continue() is called
within an interceptor.
The set_FirstName parameters are loaded into an object array.
The current instance, delegate, method name and method arguments are passed into
the methodInvocation constructor (there will be more data not illustrated here passed in when created including method info, return types, argument types etc.)
The DefaultInterceptor’s Handle method is called with
the methodInvocation instance as it’s parameter.
Obviously methods can have return values, ref and out parameters etc. in these cases
the generated method override body will be slightly different from above. I’ll go into more detail on these aspects as we build them.
Conclusion
I hope this has been useful, I can’t guarantee that
the proxy will look exactly like
the above, but at
the moment, this is pretty much what I intend to do.
Always worth downloading
the code at http://rapidioc.codeplex.com/ to see
the latest.
There will also be some tests that you can debug through to help see what’s going on.
Cheers,
Sean.
