Aufrufen einer statischen Methode für einen generischen Typparameter

Ich hatte gehofft, so etwas zu tun, aber es scheint in C # illegal zu sein:

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

Ich erhalte einen Fehler bei der Kompilierung: "'T' ist ein 'Typparameter', der im angegebenen Kontext nicht gültig ist."

Wie kann ich bei einem generischen Typparameter eine statische Methode für die generische Klasse aufrufen? Die statische Methode muss unter Berücksichtigung der Einschränkung verfügbar sein.

In diesem Fall sollten Sie die statische Methode für den eingeschränkten Typ direkt aufrufen. C # (und die CLR) unterstützen keine virtuellen statischen Methoden. So:

T.StaticMethodOnSomeBaseClassThatReturnsCollection

... kann nicht anders sein als:

SomeBaseClass.StaticMethodOnSomeBaseClassThatReturnsCollection

Das Durchlaufen des generischen Typparameters ist eine nicht benötigte Indirektion und wird daher nicht unterstützt.

Um auf eine frühere Antwort einzugehen, denke ich, dass die Reflexion näher an dem liegt, was Sie hier wollen. Ich könnte 1001 Gründe nennen, warum Sie etwas tun sollten oder nicht, ich beantworte Ihre Frage einfach wie gestellt. Ich denke, Sie sollten die GetMethod-Methode für den Typ des generischen Parameters aufrufen und von dort aus fortfahren. Zum Beispiel für eine Funktion:

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

Dabei ist T eine Klasse mit der statischen Methode fetchAll ().

Ja, ich bin mir bewusst, dass dies schrecklich langsam ist und abstürzen kann, wenn someParent nicht alle untergeordneten Klassen zwingt, fetchAll zu implementieren, aber die gestellte Frage beantwortet.

Die einzige Möglichkeit, eine solche Methode aufzurufen, wäre die Reflexion. Es scheint jedoch möglich zu sein, diese Funktionalität in eine Schnittstelle zu packen und ein instanzbasiertes IoC / factory / etc-Muster zu verwenden.

Es hört sich so an, als würden Sie versuchen, mithilfe von Generika die Tatsache zu umgehen, dass es in C # keine "virtuellen statischen Methoden" gibt.

Leider wird das nicht funktionieren.

Ab sofort kannst du nicht. Sie müssen dem Compiler mitteilen, dass T über diese Methode verfügt, und derzeit gibt es keine Möglichkeit, dies zu tun. (Viele drängen Microsoft, das zu erweitern, was in einer generischen Einschränkung angegeben werden kann, sodass dies möglicherweise in Zukunft möglich sein wird.)

Hier poste ich ein Beispiel, das funktioniert, es ist eine Problemumgehung

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

Ich wollte es nur rauswerfen, dass Delegierte diese Probleme manchmal lösen, je nach Kontext.

Wenn Sie die statische Methode als eine Art Factory- oder Initialisierungsmethode aufrufen müssen, können Sie einen Delegaten deklarieren und die statische Methode an die entsprechende generische Factory übergeben oder was auch immer diese "generische Klasse mit dieser statischen Methode" benötigt.

Beispielsweise:

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

Leider können Sie nicht erzwingen, dass die Klasse die richtige Methode hat, aber Sie können zumindest beim Kompilieren erzwingen, dass die resultierende Factory-Methode alles hat, was sie erwartet (dh eine Initialisierungsmethode mit genau der richtigen Signatur). Dies ist besser als eine Laufzeitreflexionsausnahme.

Dieser Ansatz hat auch einige Vorteile, dh Sie können Init-Methoden wiederverwenden, Instanzmethoden sein usw.

Sie sollten diese mit Reflexion tun können, wie beschrieben hier

Da der Link tot ist, habe ich die relevanten Details in der Wayback-Maschine gefunden:

Angenommen, Sie haben eine Klasse mit einer statischen generischen Methode:

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

Wie können Sie diese Methode mit relection aufrufen?

Es stellt sich als sehr einfach heraus… So rufen Sie eine statische generische Methode mit Reflection auf:

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