Wywołanie metody statycznej dla parametru typu ogólnego

Miałem nadzieję zrobić coś takiego, ale wydaje się to nielegalne w C #:

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

Pojawia się błąd kompilacji: „„ T ”to„ parametr typu ”, który nie jest prawidłowy w danym kontekście”.

Biorąc pod uwagę parametr typu ogólnego, w jaki sposób mogę wywołać metodę statyczną w klasie ogólnej? Metoda statyczna musi być dostępna, biorąc pod uwagę ograniczenie.

W takim przypadku należy bezpośrednio wywołać metodę statyczną na typie z ograniczeniami. C # (i CLR) nie obsługują wirtualnych metod statycznych. Więc:

T.StaticMethodOnSomeBaseClassThatReturnsCollection

... nie może różnić się od:

SomeBaseClass.StaticMethodOnSomeBaseClassThatReturnsCollection

Przechodzenie przez parametr typu ogólnego jest niepotrzebnym kierunkiem i dlatego nie jest obsługiwane.

Aby rozwinąć poprzednią odpowiedź, myślę, że refleksja jest bliższa temu, czego chcesz tutaj. Mógłbym podać 1001 powodów, dla których powinieneś lub nie powinieneś coś robić, po prostu odpowiem na twoje pytanie. Myślę, że powinieneś wywołać metodę GetMethod na typie parametru generycznego i przejść stamtąd. Na przykład dla funkcji:

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

Gdzie T to dowolna klasa, która ma statyczną metodę fetchAll ().

Tak, zdaję sobie sprawę, że jest to przerażająco wolne i może się zawiesić, jeśli someParent nie zmusi wszystkich swoich klas podrzędnych do implementacji funkcji fetchAll, ale odpowiada na zadane pytanie.

Jedynym sposobem wywołania takiej metody byłaby refleksja, jednak wygląda na to, że możliwe jest zawinięcie tej funkcji w interfejs i użycie wzorca IoC / factory / etc opartego na instancji.

Wygląda na to, że próbujesz użyć typów ogólnych, aby obejść fakt, że w języku C # nie ma „wirtualnych metod statycznych”.

Niestety to nie zadziała.

Na razie nie możesz. Potrzebujesz sposobu, aby powiedzieć kompilatorowi, że T ma tę metodę, a obecnie nie ma sposobu, aby to zrobić. (Wielu naciska na Microsoft, aby rozszerzył to, co można określić w ogólnym ograniczeniu, więc być może będzie to możliwe w przyszłości).

Tutaj zamieszczam przykład, który działa, to obejście

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

Chciałem tylko wyrzucić, że czasami delegaci rozwiązują te problemy, w zależności od kontekstu.

Jeśli chcesz wywołać metodę statyczną jako rodzaj fabryki lub metody inicjującej, możesz zadeklarować delegata i przekazać metodę statyczną do odpowiedniej fabryki generycznej lub cokolwiek innego, co wymaga tej „klasy ogólnej z tą metodą statyczną”.

Na przykład:

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

Niestety nie możesz wymusić, że klasa ma właściwą metodę, ale możesz przynajmniej wymusić w czasie kompilacji, że wynikowa metoda fabryczna ma wszystko, czego oczekuje (tj. Metodę inicjalizacji z dokładnie odpowiednim podpisem). Jest to lepsze niż wyjątek odbicia w czasie wykonywania.

Takie podejście ma również pewne zalety, np. Możesz ponownie użyć metod init, ustawić je jako metody instancji itp.

Powinieneś być w stanie to zrobić za pomocą refleksji, jak opisano tutaj

Ponieważ link nie działa, znalazłem odpowiednie szczegóły w maszynie zwrotnej:

Załóżmy, że masz klasę ze statyczną metodą ogólną:

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

Jak możesz przywołać tę metodę za pomocą odbicia?

Okazuje się, że jest to bardzo proste… Oto jak wywołać statyczną metodę ogólną za pomocą odbicia:

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