Creating a dynamic proxy generator with c# – Part 1 – Creating the Assembly builder, Module builder and caching mechanism Creating a dynamic proxy generator with c# – Part 2 – Interceptor Design Creating a dynamic proxy generator with c# – Part 3 – Creating the constructors The plan for calling the base methods from the proxy is to create a private
method for each overridden proxy
method, this will allow the proxy to use a delegate to simply invoke the private
method when required. Quite a few helper classes have been created to make this possible so as usual I would suggest download or viewing the code at http://rapidioc.codeplex.com/. In this post I’m just going to cover the main points for when creating methods. Getting the methods to override The first two notable methods are for getting the methods. private static MethodInfo[] GetMethodsToOverride<TBase>() where TBase : class { return typeof(TBase).GetMethods().Where(x => !methodsToIgnore.Contains(x.Name) && (x.Attributes & MethodAttributes.Final) == 0) .ToArray(); } private static StringCollection GetMethodsToIgnore() { return new StringCollection() { "ToString", "GetHashCode", "Equals", "GetType" }; } The GetMethodsToIgnore
method string collection contains an array of methods that I don’t want to override. In the GetMethodsToOverride
method, you’ll notice a binary AND which is basically saying not to include any methods marked final i.e. not virtual. Creating the MethodInfo for calling the base
method This
method should hopefully be fairly easy to follow, it’s only function is to create a MethodInfo which points to the correct base
method, and with the correct parameters. private static MethodInfo CreateCallBaseMethodInfo<TBase>(MethodInfo method) where TBase : class { Type[] baseMethodParameterTypes = ParameterHelper.GetParameterTypes(method,
method.GetParameters()); return typeof(TBase).GetMethod(
method.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, baseMethodParameterTypes, null ); } /// <summary> /// Get the parameter types. /// </summary> /// <param name="method">The
method.</param> /// <param name="parameters">The parameters.</param> public static Type[] GetParameterTypes(MethodInfo
method, ParameterInfo[] parameters) { Type[] parameterTypesList = Type.EmptyTypes; if (parameters.Length > 0) { parameterTypesList = CreateParametersList(parameters); } return parameterTypesList; } Creating the new private methods for calling the base
method The following
method outline how I’ve created the private methods for calling the base class
method. private static MethodBuilder CreateCallBaseMethodBuilder(TypeBuilder typeBuilder, MethodInfo method) { string callBaseSuffix = "GetBaseMethod"; if (method.IsGenericMethod ||
method.IsGenericMethodDefinition) { return MethodHelper.SetUpGenericMethod ( typeBuilder,
method,
method.Name + callBaseSuffix, MethodAttributes.Private | MethodAttributes.HideBySig ); } else { return MethodHelper.SetupNonGenericMethod ( typeBuilder,
method,
method.Name + callBaseSuffix, MethodAttributes.Private | MethodAttributes.HideBySig ); } } The CreateCallBaseMethodBuilder is the entry point
method for creating the
call base
method. I’ve added a suffix to the base classes
method name to keep it unique. Non Generic Methods Creating a non generic
method is fairly simple public static MethodBuilder SetupNonGenericMethod( TypeBuilder typeBuilder, MethodInfo
method, string methodName, MethodAttributes methodAttributes) { ParameterInfo[] parameters =
method.GetParameters(); Type[] parameterTypes = ParameterHelper.GetParameterTypes(method, parameters); Type returnType =
method.ReturnType; MethodBuilder methodBuilder = CreateMethodBuilder ( typeBuilder,
method, methodName, methodAttributes, parameterTypes, returnType ); ParameterHelper.SetUpParameters(parameterTypes, parameters, methodBuilder); return methodBuilder; } private static MethodBuilder CreateMethodBuilder ( TypeBuilder typeBuilder, MethodInfo
method, string methodName, MethodAttributes methodAttributes, Type[] parameterTypes, Type returnType ) { MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, methodAttributes, returnType, parameterTypes); return methodBuilder; } As you can see, you simply have to declare a
method builder, get the parameter types, and set the
method attributes you want. Generic Methods Creating generic methods takes a little bit more work. /// <summary> /// Sets up generic
method. /// </summary> /// <param name="typeBuilder">The type builder.</param> /// <param name="method">The
method.</param> /// <param name="methodName">Name of the
method.</param> /// <param name="methodAttributes">The
method attributes.</param> public static MethodBuilder SetUpGenericMethod ( TypeBuilder typeBuilder, MethodInfo
method, string methodName, MethodAttributes methodAttributes ) { ParameterInfo[] parameters =
method.GetParameters(); Type[] parameterTypes = ParameterHelper.GetParameterTypes(method, parameters); MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, methodAttributes); Type[] genericArguments =
method.GetGenericArguments(); GenericTypeParameterBuilder[] genericTypeParameters = GetGenericTypeParameters(methodBuilder, genericArguments); ParameterHelper.SetUpParameterConstraints(parameterTypes, genericTypeParameters); SetUpReturnType(method, methodBuilder, genericTypeParameters); if (method.IsGenericMethod) { methodBuilder.MakeGenericMethod(genericArguments); } ParameterHelper.SetUpParameters(parameterTypes, parameters, methodBuilder); return methodBuilder; } private static GenericTypeParameterBuilder[] GetGenericTypeParameters ( MethodBuilder methodBuilder, Type[] genericArguments ) { return methodBuilder.DefineGenericParameters(GenericsHelper.GetArgumentNames(genericArguments)); } private static void SetUpReturnType(MethodInfo
method, MethodBuilder methodBuilder, GenericTypeParameterBuilder[] genericTypeParameters) { if (method.IsGenericMethodDefinition) { SetUpGenericDefinitionReturnType(method, methodBuilder, genericTypeParameters); } else { methodBuilder.SetReturnType(method.ReturnType); } } private static void SetUpGenericDefinitionReturnType(MethodInfo
method, MethodBuilder methodBuilder, GenericTypeParameterBuilder[] genericTypeParameters) { if (method.ReturnType == null) { methodBuilder.SetReturnType(typeof(void)); } else if (method.ReturnType.IsGenericType) { methodBuilder.SetReturnType(genericTypeParameters.Where (x => x.Name ==
method.ReturnType.Name).First()); } else { methodBuilder.SetReturnType(method.ReturnType); } } Ok, there are a few helper methods missing, basically there is way to much code to put in this post, take a look at the code at http://rapidioc.codeplex.com/ to follow it through completely. Basically though, when dealing with generics there is extra work to do in terms of getting the generic argument types setting up any generic parameter constraints setting up the return type setting up the
method as a generic All of the information is easy to get via reflection from the MethodInfo. Emitting the new private
method Emitting the new private
method is relatively simple as it’s only function is calling the base
method and returning a result if the return type is not void. ILGenerator il = privateMethodBuilder.GetILGenerator(); EmitCallBaseMethod(method, callBaseMethod, il); private static void EmitCallBaseMethod(MethodInfo
method, MethodInfo callBaseMethod, ILGenerator il) { int privateParameterCount =
method.GetParameters().Length; il.Emit(OpCodes.Ldarg_0); if (privateParameterCount > 0) { for (int arg = 0; arg < privateParameterCount; arg++) { il.Emit(OpCodes.Ldarg_S, arg + 1); } } il.Emit(OpCodes.
Call, callBaseMethod); il.Emit(OpCodes.Ret); } So in the main
method building
method, an ILGenerator is created from the
method builder. The ILGenerator performs the following actions: Load the class (this) onto the stack using the hidden argument Ldarg_0. Create an argument on the stack for each of the
method parameters (starting at 1 because 0 is the hidden argument)
Call the base
method using the Opcodes.
Call code and the MethodInfo we created earlier.
Call return on the
method Conclusion Now we have the private methods prepared for calling the base
method, we have reached the last of the relatively easy part of the proxy building. Hopefully, it hasn’t been too hard to follow so far, there is a lot of code so I haven’t been able to post it all so please check it out at http://rapidioc.codeplex.com/. The next section should be up fairly soon, it’s going to cover creating the delegates for calling the private methods created in this post. Kind Regards, Sean.
