Question

I’m writing a framework, one function of which involves remotely handling events (details of which I believe aren’t relevant right now). What is needed though is the ability to hook an event handler to any event, given the target object reference and event name.

The method that handles the event will marshal/otherwise proxy the parameters to some handler code, then cast the return type to the event handler’s return type. Effectively, it wraps the handler.

I believe that due to the fact that the event handler may be required to have any number of parameters of any type, the only way to handle a request to hook an event on-demand is to use reflection/emit (code generation) to build a custom proxy method. I’m posting this question to check that assumption and see if anyone has any other/neater ideas.

Currently, I create a DynamicMethod, then do this kind of thing. It works – almost – but the wrapper method that this dynamic proxy method calls must be static (the declaration is pretty much public static object GenericHandler(object[] parameters)); I don’t want it to be. So my current task is to dynamically create a whole type, with this method, but also a field to store the instance of the object to call the wrapper on. But, that’s beside the point (I think) – I want to check that my assumption about having to create dynamic code at all is correct or not. But, for ref:

        // obj = target object, eventName = event name
        var evtInfo = obj.GetType().GetEvent(eventName);

        var handlerType = evtInfo.EventHandlerType;

        var eventInvokeMethod = handlerType.GetMethod("Invoke");
        var paramTypes = eventInvokeMethod.GetParameters().Select(p => p.ParameterType).ToArray();
        var returnType = eventInvokeMethod.ReturnType;

        var handlerMethod = new DynamicMethod(
            "evtHandler_" + eventName,
            MethodAttributes.Static | MethodAttributes.Public,
            CallingConventions.Standard,
            returnType,
            paramTypes,
            typeof(my container class).Module,
            false);

        var il = handlerMethod.GetILGenerator();

        // locals: [0] = parameter array
        il.DeclareLocal(typeof(object[]));

        // create an appropriately-sized array objects, for the parameters
        il.Emit(OpCodes.Ldc_I4, (int)paramTypes.Count());
        il.Emit(OpCodes.Newarr, typeof(object));
        il.Emit(OpCodes.Stloc_0);

        for (int i = 0; i < paramTypes.Length; i++)
        {
            // for the array: load the parameter into the same index of the array
            il.Emit(OpCodes.Ldloc_0);
            il.Emit(OpCodes.Ldc_I4, i);
            il.Emit(OpCodes.Ldarg, i);
            if (!paramTypes[i].IsClass)
            {
                // box the value first..
                il.Emit(OpCodes.Box, paramTypes[i]);
            }
            il.Emit(OpCodes.Stelem_Ref);
        }

        // call our generic handler with the array of parameters, then convert the return
        // value to the target type via unboxing or a cast
        il.Emit(OpCodes.Ldloc_0);
        il.Emit(OpCodes.Call, wrapper.GetMethodInfo());
        if (!returnType.IsClass)
        {
            il.Emit(OpCodes.Unbox_Any, returnType);
        }
        else
        {
            il.Emit(OpCodes.Castclass, returnType);
        }
        il.Emit(OpCodes.Ret);

If there are no responses and I get the above theory with wrapper type working, I’ll post updated code.. but would love to hear about alternatives to this method if they are out there.

Answer 1

It was necessary to implement (and improve upon) the above code. With a dynamically-generated assembly, type and method, I can proxy any events fired to a general object HandleEvent(object[] parameters) method.