To be honest, if you don’t know the type at compile time, there isn’t a huge amount of benefit in creating a Delegate. You don’t want to use DynamicInvoke; it will be about as slow as reflection. The main exception to this is when there is a delegate-type lurking in the shadows, for example when … Read more
You’re trying to create a delegate from an instance method, but you’re not passing in a target. You could use: Delegate.CreateDelegate(typeof(TestDelagate), this, method); … or you could make your method static. (If you need to cope with both kinds of method, you’ll need to do that conditionally, or pass in null as the middle argument.)
OK, I found a way, using GetInterfaceMap. var map = targetType.GetInterfaceMap(interfaceMethod.DeclaringType); var index = Array.IndexOf(map.InterfaceMethods, interfaceMethod); if (index == -1) { //this should literally be impossible } return map.TargetMethods[index];
Slight adaptation of a previously posted answer, but this blog post seems to achieve what you’re asking for; http://blog.functionalfun.net/2009/10/getting-methodinfo-of-generic-method.html Sample usage would be as follows; var methodInfo = SymbolExtensions.GetMethodInfo(() => Program.Main()); Original answer was to this question; https://stackoverflow.com/a/9132588/5827
You can use System.Linq.Expressions.Expression.GetDelegateType method: using System; using System.Linq; using System.Linq.Expressions; using System.Reflection; class Program { static void Main() { var writeLine = CreateDelegate(typeof(Console).GetMethod(“WriteLine”, new[] { typeof(string) })); writeLine.DynamicInvoke(“Hello world”); var readLine = CreateDelegate(typeof(Console).GetMethod(“ReadLine”, Type.EmptyTypes)); writeLine.DynamicInvoke(readLine.DynamicInvoke()); } static Delegate CreateDelegate(MethodInfo method) { if (method == null) { throw new ArgumentNullException(“method”); } if (!method.IsStatic) { throw … Read more
Use Delegate.CreateDelegate: // Static method Action action = (Action) Delegate.CreateDelegate(typeof(Action), method); // Instance method (on “target”) Action action = (Action) Delegate.CreateDelegate(typeof(Action), target, method); For an Action<T> etc, just specify the appropriate delegate type everywhere. In .NET Core, Delegate.CreateDelegate doesn’t exist, but MethodInfo.CreateDelegate does: // Static method Action action = (Action) method.CreateDelegate(typeof(Action)); // Instance method (on … Read more
You need to create the argument array first, and keep a reference to it. The out parameter value will then be stored in the array. So you can use: object[] arguments = new object[] { “test”, null }; MethodInfo method = …; bool b = (bool) method.Invoke(null, arguments); byte[] rawAsm = (byte[]) arguments[1]; Note how … Read more
You can’t use System.Void directly, but can access it using typeof(void). Several people point out (here and in the comments here for example) that the reason for this is that the ECMA Standard 335, Partition II, section 9.4 says: The following kinds of type cannot be used as arguments in instantiations (of generic types or … Read more
This kind of replaces my previous answer because this, although it’s a slightly longer route – gives you a quick method call and, unlike some of the other answers, allows you to pass through different instances (in case you’re going to encounter multiple instances of the same type). IF you don’t want that, check my … Read more