Удаление метода экземпляра в .NET

На самом деле вы выбрали особенно сложный пример по двум причинам:

• ToString() — это виртуальный метод, унаследованный от object, но переопределенный в Int32.
• int — это тип значения, и существуют странные правила с Delegate.CreateDelegate(), когда дело доходит до типов значений и методов экземпляра — в основном первым эффективным параметром становится ref int, а не int.

Однако вот пример для String.ToUpper, у которого нет ни одной из этих проблем:

using System;
using System.Reflection;

class Test
{
    static void Main()
    {
        MethodInfo method = typeof(string).GetMethod
            ("ToUpper", BindingFlags.Instance | BindingFlags.Public,
             null, new Type[]{}, null);

        Func<string, string> func = (Func<string, string>)
            Delegate.CreateDelegate(typeof(Func<string, string>),
                                    null,
                                    method);

        string x = func("hello");

        Console.WriteLine(x);
    }
}

Если этого достаточно для вас, отлично... если вы действительно хотите int.ToString, мне придется немного постараться :)

Вот пример для типа значения с использованием нового типа делегата, который принимает свой первый параметр по ссылке:

using System;
using System.Reflection;

public struct Foo
{
    readonly string value;

    public Foo(string value)
    {
        this.value = value;
    }

    public string DemoMethod()
    {
        return value;
    }
}

class Test
{
    delegate TResult RefFunc<TArg, TResult>(ref TArg arg);

    static void Main()
    {
        MethodInfo method = typeof(Foo).GetMethod
            ("DemoMethod", BindingFlags.Instance | BindingFlags.Public,
             null, new Type[]{}, null);
        RefFunc<Foo, string> func = (RefFunc<Foo, string>)
            Delegate.CreateDelegate(typeof(RefFunc<Foo, string>),
                                    null,
                                    method);

        Foo y = new Foo("hello");
        string x = func(ref y);

        Console.WriteLine(x);
    }
}

Я не уверен, но может быть Открытые делегаты могут помочь тебе.

Обновление: перейдите по этой ссылке, если первая не работает.

Вы можете использовать Lambdas, чтобы получить "несколько" скомпилированную статическую оболочку для вашего метода экземпляра.

Приведенный ниже пример не совсем молниеносно быстр, но он должен быть значительно быстрее, чем любой простой динамический вызов.

Выход

100000 iterations took 4 ms 
1000000 iterations took 18 ms 
10000000 iterations took 184 ms

Код

class Program
{

   public sealed class Test
   {
      public String Data { get; set; }
      public override string ToString()
      {
         return Data;
      }
   }

   static void Main(string[] args)
   {
      TestRun(100000);
      TestRun(1000000);
      TestRun(10000000);
   }

   private static void TestRun(int iterations)
   {
      var toString = typeof(Test).GetMethod("ToString",
                                            BindingFlags.Instance
                                            | BindingFlags.Public,
                                            null,
                                            Type.EmptyTypes,
                                            null);
      var call = GetCall<Test, String>(toString);
      var tests
         = (from i in Enumerable.Range(1, iterations)
            select new Test { Data = "..." + i }).ToList();

      var sw = Stopwatch.StartNew();
      tests.ForEach(i => call(i));
      sw.Stop();
      Console.WriteLine("{0} iterations took {1} ms", iterations, sw.ElapsedMilliseconds);
   }

   private static Func<T, M> GetCall<T, M>(MethodInfo methodInfo)
   {
      var input = Expression.Parameter(typeof(T), "input");
      MethodCallExpression member = Expression.Call(input, methodInfo);
      var lambda = Expression.Lambda<Func<T, M>>(member, input);

      return lambda.Compile();
   }
}

Гуг, возможно, может использовать «динамический» тип в .NET 4.0. Однако делегату нужен экземпляр (для нестатических методов). Проблемы более сложны, чем локки в первый раз из-за полиморфизма и т. Д.