Generics et Délégué action

Question

J'ai le code suivant:

public void generate() 
{ 
    base.generateFoo(Method); // How can i indicate the type here? 
} 

public void Method<T>(T t , IDictionary<T, SomeObject> coll) : where T : ISomething 
{ 
// do something 
} 


class MyBase 
{ 
    public void generateFoo<T>(Action<T, IDictionary<T, SomeObject>> Method) : where T : ISomething 
    { 
    Method.invoke(ObjectThatImplementsT, DictionaryWIthTKey); 
    } 
} 

J'obtiens une erreur comme ne peut pas convertir ObjectThatImplementsT à T.

je peux passer une méthode générique comme paramter à une autre méthode?

Quel est le problème ici?

Merci.

Answer 1

Vous avez probablement juste besoin de spécifier le type:

public void generate() 
{ 
    base.generateFoo<YourType>(Method); 
} 

Cela étant dit - le code ci-dessus, comme il est écrit, ne compilera pas, puisque generateFoo n'est pas une méthode générique, ni dans une classe générique, il est donc possible ce qui précède ne fonctionnera pas. Il suppose que generateFoo est défini comme une méthode générique (prenant le type T).

Answer 2

Vous pouvez créer generateFoo générique à T, avec les mêmes restrictions que Méthode. Votre exemple ne compilera pas autrement, car T est inconnu de MyBase (sauf si vous avez réellement une classe nommée T dans un espace de noms connu).

Answer 3

Toutes les applique ci-dessus, beaucoup de modifications mineures (pourquoi vous compilez votre échantillon vous afin que nous puissions savoir pas ce que des « problèmes » sont faux et ce qui est vraiment votre question ?!)

Voici une compilation bits - noter trois variantes de l'appel generateFoo:

using System.Collections.Generic; 
using System; 

namespace X 
{ 
    class Y : MyBase 
    { 
     public static void Main(string[]args) { } 

     public void generate() 
     { 
      base.generateFoo<Something>(Method<Something>); // works 
      base.generateFoo<Something>(Method); // works as well 
      base.generateFoo(Method<Something>); // doesn't (cannot be inferred) 
     } 

     public void Method<T>(T t , IDictionary<T, SomeObject> coll) 
      where T : ISomething 
     { 
      // do something 
     } 

    } 

    class MyBase 
    { 
     public void generateFoo<T>(Action<T, IDictionary<T, SomeObject>> Method) 
      where T : class, ISomething 
     { 
      Method.Invoke((T) null, new Dictionary<T,SomeObject>()); 
     } 
    } 
    internal interface ISomething {} 
    internal class Something : ISomething {} 
    internal class SomeObject {} 
}