Llamar a un método estático en un parámetro de tipo genérico

Esperaba hacer algo como esto, pero parece ser ilegal en C #:

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

Recibo un error en tiempo de compilación: "'T' es un 'parámetro de tipo', que no es válido en el contexto dado".

Dado un parámetro de tipo genérico, ¿cómo puedo llamar a un método estático en la clase genérica? El método estático debe estar disponible, dada la restricción.

En este caso, debe llamar directamente al método estático en el tipo restringido. C # (y CLR) no admiten métodos estáticos virtuales. Entonces:

T.StaticMethodOnSomeBaseClassThatReturnsCollection

... no puede ser diferente a:

SomeBaseClass.StaticMethodOnSomeBaseClassThatReturnsCollection

Pasar por el parámetro de tipo genérico es una indirección innecesaria y, por lo tanto, no es compatible.

Para desarrollar una respuesta anterior, creo que la reflexión está más cerca de lo que quieres aquí. Podría dar 1001 razones por las que debería o no debería hacer algo, solo responderé a su pregunta tal como se me pide. Creo que deberías llamar al método GetMethod en el tipo de parámetro genérico e ir desde allí. Por ejemplo, para una función:

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

Donde T es cualquier clase que tenga el método estático fetchAll ().

Sí, soy consciente de que esto es terriblemente lento y puede fallar si someParent no fuerza a todas sus clases secundarias a implementar fetchAll pero responde la pregunta tal como se le preguntó.

La única forma de llamar a dicho método sería a través de la reflexión. Sin embargo, parece que podría ser posible envolver esa funcionalidad en una interfaz y usar un patrón IoC / factory / etc. basado en instancias.

Parece que está intentando utilizar genéricos para evitar el hecho de que no existen "métodos estáticos virtuales" en C #.

Desafortunadamente, eso no va a funcionar.

A partir de ahora, no puedes. Necesita una forma de decirle al compilador que T tiene ese método y, actualmente, no hay forma de hacerlo. (Muchos están presionando a Microsoft para que expanda lo que se puede especificar en una restricción genérica, por lo que tal vez esto sea posible en el futuro).

Aquí, publico un ejemplo que funciona, es una solución

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

Solo quería decir que a veces los delegados resuelven estos problemas, según el contexto.

Si necesita llamar al método estático como una especie de fábrica o método de inicialización, entonces puede declarar un delegado y pasar el método estático a la fábrica genérica relevante o lo que sea que necesite esta "clase genérica con este método estático".

Por ejemplo:

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

Desafortunadamente, no puede hacer cumplir que la clase tenga el método correcto, pero al menos puede hacer cumplir en tiempo de compilación que el método de fábrica resultante tenga todo lo que espera (es decir, un método de inicialización con exactamente la firma correcta). Esto es mejor que una excepción de reflexión en tiempo de ejecución.

Este enfoque también tiene algunos beneficios, es decir, puede reutilizar métodos init, hacer que sean métodos de instancia, etc.

Debería poder hacer esto usando la reflexión, como se describe aquí

Debido a que el enlace está muerto, encontré los detalles relevantes en la máquina de retorno:

Suponga que tiene una clase con un método genérico estático:

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

¿Cómo puedes invocar este método usando relección?

Resulta muy fácil ... Así es como se invoca un método genérico estático usando la reflexión:

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