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.
