In a previous post about delegates, I discussed the following interesting cases of delegates:
- Closed static
- Open instance
See the previous post for the full explanation, but these basically open up some interesting dynamic scenarios. The problem is that C# and VB do not expose syntax for constructing these in an "early-bound" fashion, that is using the special constructor on the delegate type rather than Delegate.CreateDelegate (which more or less binds via reflection).
For most scenarios this is not a huge problem, but there are some performance considerations and other issues to consider that I don't really want to dig into at the moment. One sufficiently important scenario is testing early-bound invocation. If your language doesn't support something, how can you test it? Well, you can write the whole test in IL, but that is not a terribly maintainable proposition.
Another option is to only write the part you need in IL. Unfortunately, C# doesn't allow you to write inline IL, but you can use Reflection.Emit. And, since v2.0, you can use LCG (Lightweight Code Generation) via DynamicMethod.
The trick here is to understand how delegates are instantiated. Delegates are just classes like any other. They inherit from MulticastDelegate (typically). The special part is that the runtime provides all the implementation and they have a special constructor. Here's (approximately) the constructor signature for System.Action<T>:
public Action(object o, IntPtr method)
Object? IntPtr? What the heck? Well, it's not as bizarre as you might think. The object is simply the first argument for the invocation. This allows binding to a particular instance ("this" for instance methods, arg 0 for static methods). The IntPtr is a pointer to the method. "Pointers?!!?!?! in managed code?!?!" you say? That's right, a pointer. An object is easy enough to come by, but where do I get the pointer? Well, the pointer can be easily retrieved via the ldftn opcode. It loads the address of a given method (described via a token in IL, and a MethodInfo in Reflection.Emit).
Lets cut to the chase. Here's a little class that can bind a method to a delegate type and allow you to provide the first argument (you'll need System, System.Reflection, System.Reflection.Emit using statements):
public static class DelegateBinder {
public delegate TDelegate Binder<TDelegate>(object firstArg);
public static TDelegate Bind<TDelegate>(object firstArg, MethodInfo method) {
DynamicMethod dynMethod = new DynamicMethod("PassthroughBinderImplementation", typeof(TDelegate), new Type[] { typeof(object) }, typeof(DelegateBinder));
ILGenerator gen = dynMethod.GetILGenerator();
//load the first argument
gen.Emit(OpCodes.Ldarg_0);
//load the address of the method
gen.Emit(OpCodes.Ldftn, method);
//create the delegate
gen.Emit(OpCodes.Newobj, typeof(TDelegate).GetConstructor(new Type[] { typeof(object), typeof(IntPtr) }));
gen.Emit(OpCodes.Ret);
return ((Binder<TDelegate>)dynMethod.CreateDelegate(typeof(Binder<TDelegate>)))(firstArg);
}
}
With this class, you can dynamically construct all the early-bound variants (ignoring variants for signature relaxation) like so:
using System;
using System.Reflection;
using System.Reflection.Emit;
public delegate string Passthrough(string str);
public delegate string BoundPassthrough();
public delegate string ProgramPassthrough(Program p);
public class Program {
static void Main(string[] args) {
Console.WriteLine("Open Static:");
Passthrough ospt = DelegateBinder.Bind<Passthrough>(null, typeof(Program).GetMethod("StaticImplementation", new Type[] { typeof(string) }));
Console.WriteLine(ospt("Hello World"));
Console.WriteLine("Closed static:");
BoundPassthrough cspt = DelegateBinder.Bind<BoundPassthrough>("Hello World", typeof(Program).GetMethod("StaticImplementation", new Type[] { typeof(string) }));
Console.WriteLine(cspt());
Console.WriteLine("Open Instance:");
ProgramPassthrough oipt = DelegateBinder.Bind<ProgramPassthrough>(null, typeof(Program).GetMethod("InstanceImplementation", Type.EmptyTypes));
Console.WriteLine(oipt(new Program("Hello World")));
Console.WriteLine("Closed Instance:");
BoundPassthrough cipt = DelegateBinder.Bind<BoundPassthrough>(new Program("Hello World"), typeof(Program).GetMethod("InstanceImplementation", Type.EmptyTypes));
Console.WriteLine(cipt());
}
public static string StaticImplementation(string str) {
return str;
}
public Program(string payload) {
_Payload = payload;
}
string _Payload;
public string InstanceImplementation() {
return _Payload;
}
}
So, there are certainly cases that will break this, most involving incompatible signature issues between the method, delegate, and the first argument. But I didn't want to make things more complicated for an example. Besides, the point of this is not really to give you some neat tool (you'll probably never need to do this), but to give people a better idea what the compiler is doing for you when you create a delegate.