Appel d'une méthode statique sur un paramètre de type générique

J'espérais faire quelque chose comme ça, mais cela semble être illégal en C #:

public Collection MethodThatFetchesSomething<T>()
    where T : SomeBaseClass
{
    return T.StaticMethodOnSomeBaseClassThatReturnsCollection();
}

J'obtiens une erreur de compilation: "" T "est un" paramètre de type ", qui n'est pas valide dans le contexte donné."

Étant donné un paramètre de type générique, comment puis-je appeler une méthode statique sur la classe générique? La méthode statique doit être disponible, compte tenu de la contrainte.

Dans ce cas, vous devez simplement appeler la méthode statique directement sur le type contraint. C # (et le CLR) ne prennent pas en charge les méthodes statiques virtuelles. Alors:

T.StaticMethodOnSomeBaseClassThatReturnsCollection

... ne peut être différent de:

SomeBaseClass.StaticMethodOnSomeBaseClassThatReturnsCollection

Passer par le paramètre de type générique est une indirection inutile et n'est donc pas prise en charge.

Pour développer une réponse précédente, je pense que la réflexion est plus proche de ce que vous voulez ici. Je pourrais donner 1001 raisons pour lesquelles vous devriez ou ne devriez pas faire quelque chose, je répondrai simplement à votre question telle que vous l'avez posée. Je pense que vous devriez appeler la méthode GetMethod sur le type du paramètre générique et partir de là. Par exemple, pour une fonction:

public void doSomething<T>() where T : someParent
{
    List<T> items=(List<T>)typeof(T).GetMethod("fetchAll").Invoke(null,new object[]{});
    //do something with items
}

Où T est une classe qui a la méthode statique fetchAll ().

Oui, je suis conscient que cela est horriblement lent et peut planter si someParent ne force pas toutes ses classes enfants à implémenter fetchAll mais il répond à la question comme demandé.

La seule façon d'appeler une telle méthode serait par réflexion. Cependant, il semble qu'il soit possible d'encapsuler cette fonctionnalité dans une interface et d'utiliser un modèle IoC / factory / etc basé sur une instance.

Il semble que vous essayez d'utiliser des génériques pour contourner le fait qu'il n'y a pas de «méthodes statiques virtuelles» en C #.

Malheureusement, cela ne fonctionnera pas.

A partir de maintenant, vous ne pouvez pas. Vous avez besoin d'un moyen de dire au compilateur que T a cette méthode, et actuellement, il n'y a aucun moyen de le faire. (Beaucoup poussent Microsoft à étendre ce qui peut être spécifié dans une contrainte générique, donc peut-être que cela sera possible à l'avenir).

Ici, je poste un exemple qui fonctionne, c'est une solution de contournement

public interface eInterface {
    void MethodOnSomeBaseClassThatReturnsCollection();
}

public T:SomeBaseClass, eInterface {

   public void MethodOnSomeBaseClassThatReturnsCollection() 
   { StaticMethodOnSomeBaseClassThatReturnsCollection() }

}

public Collection MethodThatFetchesSomething<T>() where T : SomeBaseClass, eInterface
{ 
   return ((eInterface)(new T()).StaticMethodOnSomeBaseClassThatReturnsCollection();
}

Je voulais juste dire que parfois les délégués résolvent ces problèmes, selon le contexte.

Si vous devez appeler la méthode statique comme une sorte de fabrique ou de méthode d'initialisation, vous pouvez déclarer un délégué et passer la méthode statique à la fabrique générique appropriée ou à tout ce qui a besoin de cette "classe générique avec cette méthode statique".

Par exemple:

class Factory<TProduct> where TProduct : new()
{
    public delegate void ProductInitializationMethod(TProduct newProduct);


    private ProductInitializationMethod m_ProductInitializationMethod;


    public Factory(ProductInitializationMethod p_ProductInitializationMethod)
    {
        m_ProductInitializationMethod = p_ProductInitializationMethod;
    }

    public TProduct CreateProduct()
    {
        var prod = new TProduct();
        m_ProductInitializationMethod(prod);
        return prod;
    }
}

class ProductA
{
    public static void InitializeProduct(ProductA newProduct)
    {
        // .. Do something with a new ProductA
    }
}

class ProductB
{
    public static void InitializeProduct(ProductB newProduct)
    {
        // .. Do something with a new ProductA
    }
}

class GenericAndDelegateTest
{
    public static void Main()
    {
        var factoryA = new Factory<ProductA>(ProductA.InitializeProduct);
        var factoryB = new Factory<ProductB>(ProductB.InitializeProduct);

        ProductA prodA = factoryA.CreateProduct();
        ProductB prodB = factoryB.CreateProduct();
    }
}

Malheureusement, vous ne pouvez pas garantir que la classe a la bonne méthode, mais vous pouvez au moins faire en sorte que la méthode de fabrique résultante ait tout ce qu'elle attend (c'est-à-dire une méthode d'initialisation avec exactement la bonne signature). C'est mieux qu'une exception de réflexion d'exécution.

Cette approche présente également certains avantages, c'est-à-dire que vous pouvez réutiliser les méthodes d'initialisation, les utiliser comme méthodes d'instance, etc.

Vous devriez pouvoir le faire en utilisant la réflexion, comme décrit ici

En raison du lien mort, j'ai trouvé les détails pertinents dans la machine de retour:

Supposons que vous ayez une classe avec une méthode générique statique:

class ClassWithGenericStaticMethod
{
    public static void PrintName<T>(string prefix) where T : class
    {
        Console.WriteLine(prefix + " " + typeof(T).FullName);
    }
}

Comment pouvez-vous invoquer cette méthode en utilisant la relection?

Cela s'avère très simple… Voici comment invoquer une méthode générique statique à l'aide de la réflexion:

// Grabbing the type that has the static generic method
Type typeofClassWithGenericStaticMethod = typeof(ClassWithGenericStaticMethod);

// Grabbing the specific static method
MethodInfo methodInfo = typeofClassWithGenericStaticMethod.GetMethod("PrintName", System.Reflection.BindingFlags.Static | BindingFlags.Public);

// Binding the method info to generic arguments
Type[] genericArguments = new Type[] { typeof(Program) };
MethodInfo genericMethodInfo = methodInfo.MakeGenericMethod(genericArguments);

// Simply invoking the method and passing parameters
// The null parameter is the object to call the method from. Since the method is
// static, pass null.
object returnValue = genericMethodInfo.Invoke(null, new object[] { "hello" });