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.
