Genel bir tür parametresinde statik bir yöntemi çağırma

Böyle bir şey yapmayı umuyordum, ancak C # 'da yasa dışı gibi görünüyor:

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

Derleme zamanı hatası alıyorum: "'T', verilen bağlamda geçerli olmayan bir 'tür parametresidir."

Genel bir tür parametresi verildiğinde, genel sınıfta statik bir yöntemi nasıl çağırabilirim? Kısıtlama göz önüne alındığında statik metot mevcut olmalıdır.

Bu durumda, sadece kısıtlı tipte statik yöntemi doğrudan çağırmalısınız. C # (ve CLR) sanal statik yöntemleri desteklemez. Yani:

T.StaticMethodOnSomeBaseClassThatReturnsCollection

... şundan farklı olamaz:

SomeBaseClass.StaticMethodOnSomeBaseClassThatReturnsCollection

Genel tür parametresinden geçmek gereksiz bir yönlendirmedir ve bu nedenle desteklenmez.

Önceki bir cevabı detaylandırmak için, burada düşünmek istediğiniz şeye daha yakın olduğunu düşünüyorum. Bir şeyi neden yapmanız veya yapmamanız gerektiğine dair 1001 neden verebilirim, sorduğunuz soruyu cevaplayacağım. Bence jenerik parametrenin türü üzerinde GetMethod yöntemini çağırmalı ve oradan gitmelisiniz. Örneğin, bir işlev için:

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

T, fetchAll () statik yöntemine sahip herhangi bir sınıftır.

Evet, bunun korkunç derecede yavaş olduğunun farkındayım ve eğer bazıParent tüm alt sınıflarını fetchAll uygulamaya zorlamazsa çökebilir, ancak soruyu sorulduğu gibi yanıtlar.

Böyle bir yöntemi çağırmanın tek yolu yansıma yoluyla olabilir, ancak bu işlevselliği bir arayüze sarmak ve örnek tabanlı bir IoC / fabrika / vb. Model kullanmak mümkün olabilir.

Görünüşe göre C # 'da "sanal statik yöntemler" olmadığı gerçeğini çözmek için jenerikleri kullanmaya çalışıyorsunuz.

Maalesef bu işe yaramayacak.

Şu an için yapamazsınız. Derleyiciye T'nin bu yönteme sahip olduğunu söylemenin bir yoluna ihtiyacınız var ve şu anda bunu yapmanın bir yolu yok. (Birçoğu Microsoft'u genel bir kısıtlamada belirtilebilecekleri genişletmeye zorluyor, bu nedenle bu gelecekte mümkün olabilir).

Burada işe yarayan bir örnek gönderiyorum, bu bir geçici çözüm

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

Ben sadece içeriğe bağlı olarak bazen delegelerin bu sorunları çözdüğünü ortaya koymak istedim.

Statik yöntemi bir tür fabrika veya başlatma yöntemi olarak çağırmanız gerekiyorsa, bir temsilci bildirebilir ve statik yöntemi ilgili genel fabrikaya veya bu "bu statik yöntemle genel sınıf" a ihtiyaç duyan her neyse, iletebilirsiniz.

Örneğin:

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

Ne yazık ki, sınıfın doğru yönteme sahip olmasını zorlayamazsınız, ancak sonuçta ortaya çıkan fabrika yönteminin beklediği her şeye sahip olduğunu (yani, tam olarak doğru imzaya sahip bir başlatma yöntemi) en azından derleme-zamanı zorlayabilirsiniz. Bu, çalışma zamanı yansıtma istisnasından daha iyidir.

Bu yaklaşımın bazı faydaları da vardır, yani init yöntemlerini yeniden kullanabilir, örnek yöntemleri olmasını sağlayabilirsiniz, vb.

Bunu burada açıklandığı gibi yansıma kullanarak yapabilmelisiniz

Bağlantının kopması nedeniyle, geri dönüş makinesinde ilgili ayrıntıları buldum:

Statik bir genel yönteme sahip bir sınıfınız olduğunu varsayalım:

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

İlişkiyi kullanarak bu yöntemi nasıl çağırabilirsiniz?

Görünüşe göre çok kolay… Düşünmeyi kullanarak Statik Genel Yöntemi şu şekilde Çağırırsınız:

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