c# - Open delegate for generic interface method

Question

I'm trying to create an open instance delegate for a generic interface method, but I keep receiving a NotSupportedException. Here is the simplified code that won't run:

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);
}

The last line throws NotSupportedException, "Specified method is not supported". By comparison, a non-generic open instance delegate runs fine:

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);
}

And a closed generic delegate also works:

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);
}

So the recipe for closed generic delegates and open instance delegates work separately, but not when combined. It's starting to look like either a runtime bug, or intentional omission. Anyone have any insight here?

Answer 1

This is a recap of the topic and this specific issue for those that find this question (since it seems the OP has already got his answer on Microsoft Connect).

---

Answer

Creating an open instance generic delegate for a generic interface method is impossible (As confirmed by Microsoft here). Currently, it is possible to implement any of the following combinations of open-instance/closed static, generic/non-generic, interface/class methods (with code samples provided at the end of the answer):

• open instance non-generic delegate for a non-generic interface method
• closed static generic delegate for a generic interface method
• closed static non-generic delegate for a non-generic interface method
• open instance generic delegate for a generic class method
• open instance non-generic delegate for a non-generic class method
• closed static generic delegate for a generic class method
• closed static non-generic delegate for a non-generic class method

Usually, the best replacement for an open instance generic delegate for a generic interface method is an open instance generic delegate for a generic class method.

---

Code Samples

• open instance non-generic delegate for a non-generic interface method

  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);
  }
  

• closed static generic delegate for a generic interface method

    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);
    }
  

• closed static non-generic delegate for a non-generic interface method

    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<int>), new Foo(), bar);
    }
  

• open instance generic delegate for a generic class method

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

• open instance non-generic delegate for a non-generic class method

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

• closed static generic delegate for a generic class method

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

• closed static non-generic delegate for a non-generic class method

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

  ---