Memanggil metode statis pada parameter tipe generik

Saya berharap untuk melakukan sesuatu seperti ini, tetapi tampaknya ilegal di C #:

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

Saya mendapatkan kesalahan waktu kompilasi: "'T' adalah 'parameter tipe', yang tidak valid dalam konteks yang diberikan."

Diberikan parameter tipe generik, bagaimana saya dapat memanggil metode statis pada kelas generik? Metode statis harus tersedia, mengingat batasannya.

Dalam hal ini Anda hanya perlu memanggil metode statis pada tipe yang dibatasi secara langsung. C # (dan CLR) tidak mendukung metode statis virtual. Begitu:

T.StaticMethodOnSomeBaseClassThatReturnsCollection

... tidak bisa berbeda dengan:

SomeBaseClass.StaticMethodOnSomeBaseClassThatReturnsCollection

Melalui parameter tipe generik adalah tipuan yang tidak dibutuhkan dan karenanya tidak didukung.

Untuk menguraikan jawaban sebelumnya, menurut saya refleksi lebih dekat dengan apa yang Anda inginkan di sini. Saya dapat memberikan 1001 alasan mengapa Anda harus atau tidak harus melakukan sesuatu, saya akan menjawab pertanyaan Anda seperti yang ditanyakan. Saya pikir Anda harus memanggil metode GetMethod pada jenis parameter generik dan pergi dari sana. Misalnya, untuk suatu fungsi:

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

Di mana T adalah kelas apa pun yang memiliki metode statis fetchAll ().

Ya, saya sadar ini sangat lambat dan mungkin macet jika someParent tidak memaksa semua kelas turunannya untuk mengimplementasikan fetchAll tetapi menjawab pertanyaan seperti yang ditanyakan.

Satu-satunya cara untuk memanggil metode semacam itu adalah melalui refleksi, Namun, sepertinya dimungkinkan untuk menggabungkan fungsionalitas itu dalam antarmuka dan menggunakan pola IoC / pabrik / dll berbasis instans.

Sepertinya Anda mencoba menggunakan obat generik untuk mengatasi fakta bahwa tidak ada "metode statis virtual" di C #.

Sayangnya, itu tidak akan berhasil.

Sampai sekarang, Anda tidak bisa. Anda memerlukan cara untuk memberi tahu kompilator bahwa T memiliki metode itu, dan saat ini, tidak ada cara untuk melakukannya. (Banyak yang mendorong Microsoft untuk memperluas apa yang dapat ditentukan dalam batasan umum, jadi mungkin ini akan memungkinkan di masa mendatang).

Di sini, saya memposting contoh yang berhasil, itu solusinya

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

Saya hanya ingin menunjukkan bahwa terkadang delegasi memecahkan masalah ini, tergantung pada konteksnya.

Jika Anda perlu memanggil metode statis sebagai semacam pabrik atau metode inisialisasi, Anda dapat mendeklarasikan delegasi dan meneruskan metode statis ke pabrik generik yang relevan atau apa pun yang membutuhkan "kelas generik dengan metode statis ini".

Sebagai contoh:

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

Sayangnya Anda tidak dapat memaksakan bahwa kelas memiliki metode yang tepat, tetapi Anda setidaknya dapat mengkompilasi-waktu-menegakkan bahwa metode pabrik yang dihasilkan memiliki semua yang diharapkan (yaitu metode inisialisasi dengan tanda tangan yang tepat). Ini lebih baik daripada pengecualian refleksi waktu proses.

Pendekatan ini juga memiliki beberapa keuntungan, yaitu Anda dapat menggunakan kembali metode init, menjadikannya metode instance, dll.

Anda harus dapat melakukan ini dengan menggunakan refleksi, seperti yang dijelaskan di sini

Karena tautan mati, saya menemukan detail yang relevan di mesin wayback:

Asumsikan Anda memiliki kelas dengan metode generik statis:

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

Bagaimana Anda bisa menggunakan metode ini menggunakan releksi?

Ternyata sangat mudah… Beginilah cara Anda Memanggil Metode Generik Statis menggunakan Refleksi:

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