通用接口方法的开放委托

Question

我正在尝试为通用接口方法创建 开放实例委托，但我保留收到 NotSupportedException。下面是不会运行的简化代码：

interface IFoo
{
    void Bar<T>(T j);
}
class Foo : IFoo
{
    public void Bar<T>(T j)
    {
    }
}
static void Main(string[] args)
{
    var bar = typeof(IFoo).GetMethod("Bar").MakeGenericMethod(typeof(int));
    var x = Delegate.CreateDelegate(typeof(Action<IFoo, int>), null, bar);
}

最后一行抛出 NotSupportedException，“不支持指定的方法”。相比之下，非泛型开放实例委托运行良好：

interface IFoo
{
    void Bar(int j);
}
class Foo : IFoo
{
    public void Bar(int j)
    {
    }
}
static void Main(string[] args)
{
    var bar = typeof(IFoo).GetMethod("Bar");
    var x = Delegate.CreateDelegate(typeof(Action<IFoo, int>), null, bar);
}

并且封闭泛型委托也可以工作：

interface IFoo
{
    void Bar<T>(T j);
}
class Foo : IFoo
{
    public void Bar<T>(T j)
    {
    }
}
static void Main(string[] args)
{
    var bar = typeof(IFoo).GetMethod("Bar").MakeGenericMethod(typeof(int));
    var x = Delegate.CreateDelegate(typeof(Action<int>), new Foo(), bar);
}

因此封闭泛型委托和开放实例委托的配方可以单独工作，但组合时则不行。它开始看起来像是一个运行时错误，或者是故意遗漏。这里有人有任何见解吗？

Answer 1

这是针对那些找到此问题的人的主题和特定问题的回顾（因为 OP 似乎已经在 Microsoft Connect 上得到了答案）。

---

答案

为通用接口方法创建开放实例通用委托是不可能的（正如 Microsoft 此处）。
目前，可以实现以下任意开放实例/封闭静态、泛型/非泛型、接口/类方法的组合（答案末尾提供了代码示例）

• ：非泛型接口方法
• 泛型接口方法的封闭静态泛型委托
• 非泛型接口方法的封闭静态非泛型委托 泛型
• 类方法的开放实例泛型委托
• 非泛型类方法的开放实例非泛型委托
• 泛型类方法的封闭静态泛型委托
• 非泛型类方法的封闭式静态非泛型委托

通常，泛型接口方法的开放实例泛型委托的最佳替代方案是泛型类方法的开放实例泛型委托。

---

代码示例

• 为非泛型接口方法打开实例非泛型委托

  接口 IFoo
  {
    无效酒吧（int j）；
  }
  
  Foo 类：IFoo
  {
    公共无效酒吧（int j）
    {
    }
  }
  
  静态无效主（字符串[]参数）
  {
    var bar = typeof(IFoo).GetMethod("Bar");
    var x = Delegate.CreateDelegate(typeof(Action), null, bar);
  }
  

• 泛型接口方法的封闭静态泛型委托

   接口 IFoo
    {
      无效Bar(Tj)；
    }
  
    Foo 类：IFoo
    {
      public void Bar(T j)
      {
      }
    }
  
    静态无效主（字符串[]参数）
    {
      var bar = typeof(IFoo).GetMethod("Bar").MakeGenericMethod(typeof(int));
      var x = Delegate.CreateDelegate(typeof(Action), new Foo(), bar);
    }
  

• 非泛型接口方法的封闭静态非泛型委托

   接口 IFoo
    {
      无效酒吧（int j）；
    }
  
    Foo 类：IFoo
    {
      公共无效酒吧（int j）
      {
      }
    }
  
    静态无效主（字符串[]参数）
    {
      var bar = typeof(IFoo).GetMethod("Bar");
      var x = Delegate.CreateDelegate(typeof(Action), new Foo(), bar);
    }
  

• 泛型类方法的开放实例泛型委托

  类 Foo
  {
      public void Bar(T j)
      {
      }
  }
  
  静态无效主（字符串[]参数）
  {
      var bar = typeof(Foo).GetMethod("Bar").MakeGenericMethod(typeof(int));
      var x = Delegate.CreateDelegate(typeof(Action), null, bar);
  }
  

• 为非泛型类方法打开实例非泛型委托

  类 Foo
  {
      公共无效酒吧（int j）
      {
      }
  }
  
  静态无效主（字符串[]参数）
  {
      var bar = typeof(Foo).GetMethod("Bar");
      var x = Delegate.CreateDelegate(typeof(Action), null, bar);
  }
  

• 泛型类方法的封闭静态泛型委托

  类 Foo
  {
      public void Bar(T j)
      {
      }
  }
  
  静态无效主（字符串[]参数）
  {
      var bar = typeof(Foo).GetMethod("Bar").MakeGenericMethod(typeof(int));
      var x = Delegate.CreateDelegate(typeof(Action), new Foo(), bar);
  }
  

• 非泛型类方法的封闭静态非泛型委托

  类 Foo
  {
      公共无效酒吧（int j）
      {
      }
  }
  
  静态无效主（字符串[]参数）
  {
      var bar = typeof(Foo).GetMethod("Bar");
      var x = Delegate.CreateDelegate(typeof(Action), new Foo(), bar);
  }
  

  ---

Answer 2

不同寻常的是，如果您确实需要这个并且不介意在问题上投入太多基础设施，则可以使用 ldvirtftn 和 calli。

这对我来说似乎很奇怪，因为我认为委托在幕后所做的基本上是执行以下操作...

public class MyAction{
public virtual void Invoke(SomeClass @this)
{
    ldarg.1
    dup
    ldvirtftn SomeClass.GenericMethod<Int32>
    calli void *(argument)
    ret
}

Ldvirtftn 进行查找以找出要为此特定调用的函数指针方法。如果您使用非虚拟泛型方法，则性能与绑定到同一函数的委托大致相同。如果它是一个虚拟通用方法，它的速度大约是原来的两倍，这表明它仍然有效，所以这是一个很大的改进。
我使用 Reflection.emit 创建了这个，它似乎工作得很好，它可以调用一个封闭的虚拟通用方法。不幸的是，与委托不同，此类型绑定到特定方法。然而，令人头疼的是运行时不允许您创建使用 ldvirtftn 、 ldftn 或 calli 的动态方法> 操作码。

    public class SomeType
    {
        public virtual void DoNothing<T>()
        {
            Console.WriteLine(typeof(T));
        }
    }

    public abstract class MyAction
    {
        public abstract void Invoke(SomeType type);
    }


    public static void Main(string[] args)
    {
        TypeBuilder builder = AppDomain.CurrentDomain
            .DefineDynamicAssembly(new AssemblyName(MethodBase.GetCurrentMethod().DeclaringType.Name),
                                   AssemblyBuilderAccess.RunAndCollect)
            .DefineDynamicModule("Module").DefineType("MyType",
                                                      TypeAttributes.AnsiClass | TypeAttributes.AutoClass | TypeAttributes.Class |
                                                      TypeAttributes.Public | TypeAttributes.Sealed,
                                                      typeof (MyAction));
        var ilgen = builder.DefineMethod("Invoke",
                                         MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.Final |
                                         MethodAttributes.Virtual,
                                         CallingConventions.HasThis,
                                         typeof (void), new[] {typeof (SomeType)}).GetILGenerator();
        ilgen.Emit(OpCodes.Ldarg_1);
        ilgen.Emit(OpCodes.Dup);
        ilgen.Emit(OpCodes.Ldvirtftn, typeof (SomeType).GetMethod("DoNothing").MakeGenericMethod(typeof (int)));
        ilgen.Emit(OpCodes.Calli, SignatureHelper.GetMethodSigHelper(CallingConventions.HasThis, typeof (void)));
        ilgen.Emit(OpCodes.Ret);
        MyAction action = Activator.CreateInstance(builder.CreateType()) as MyAction;
        action.Invoke(new SomeType());
    }

如果您可以使用代码生成，则可以使用表达式树或动态方法来调用该方法。它比直接委托慢一点，但我们谈论的是很小的开销。

Answer 3

Microsoft已回答这是一个已知问题，CLR 无法做到这一点，但在当前版本的 .NET 中无法解决。正如我在那里解释的那样，仍然不清楚为什么这是不可能的。由于某种原因，开放委托不得重用 CLR 中其他地方使用的调度逻辑，这对我来说似乎很奇怪。