ジェネリック型パラメーターで静的メソッドを呼び出す

私はこのようなことをしたいと思っていましたが、C＃では違法であるようです：

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

「T」は「タイプパラメータ」であり、指定されたコンテキストでは無効です。コンパイル時エラーが発生します。

ジェネリック型パラメーターが指定された場合、ジェネリッククラスで静的メソッドを呼び出すにはどうすればよいですか？制約が与えられた場合、静的メソッドが利用可能である必要があります。

この場合、制約された型の静的メソッドを直接呼び出すだけです。C＃（およびCLR）は、仮想静的メソッドをサポートしていません。そう：

T.StaticMethodOnSomeBaseClassThatReturnsCollection

...以下と同じにすることができます：

SomeBaseClass.StaticMethodOnSomeBaseClassThatReturnsCollection

ジェネリック型パラメーターを通過することは、不要な間接参照であるため、サポートされていません。

以前の回答について詳しく述べると、ここでの反省はあなたが望むものに近いと思います。あなたが何かをすべきか、すべきでない理由を1001挙げることができます。私は尋ねられた質問に答えます。ジェネリックパラメーターの型でGetMethodメソッドを呼び出して、そこから移動する必要があると思います。たとえば、関数の場合：

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（）を持つクラスです。

はい、私はこれが恐ろしく遅いことを知っており、someParentがすべての子クラスにfetchAllの実装を強制しない場合にクラッシュする可能性がありますが、尋ねられた質問に答えます。

このようなメソッドを呼び出す唯一の方法はリフレクションを経由することですが、その機能をインターフェイスにラップし、インスタンスベースのIoC /ファクトリー/などのパターンを使用することは可能なように思えます。

ジェネリックを使用してC＃に「仮想静的メソッド」がないという事実を回避しようとしているようです。

残念ながら、それはうまくいきません。

今のところできません。Tがそのメソッドを持っていることをコンパイラーに伝える方法が必要ですが、現在、その方法はありません。（多くは、マイクロソフトに一般的な制約で指定できるものを拡張するように強いているので、おそらくこれは将来的に可能になるでしょう）。

ここで、私はうまくいく例を投稿します、それは回避策です

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

状況によっては、デリゲートがこれらの問題を解決することもあります。

静的メソッドを何らかのファクトリまたは初期化メソッドとして呼び出す必要がある場合は、デリゲートを宣言して、静的メソッドを関連する汎用ファクトリまたはこの「静的メソッドを持つ汎用クラス」を必要とするものに渡すことができます。

例えば：

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

残念ながら、クラスに適切なメソッドがあることを強制することはできませんが、少なくともコンパイル時に、結果のファクトリーメソッドが期待するすべてのもの（つまり、正確に正しいシグネチャを持つ初期化メソッド）を持っていることを強制できます。これは、実行時リフレクション例外よりも優れています。

このアプローチにはいくつかの利点もあります。つまり、initメソッドを再利用したり、インスタンスメソッドにしたりすることができます。

ここで説明するように、リフレクションを使用してこれを行うことができるはずです

リンクが停止しているため、ウェイバックマシンに関連する詳細が見つかりました。

静的なジェネリックメソッドを持つクラスがあるとします。

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

リレーションを使用してこのメ​​ソッドをどのように呼び出すことができますか？

非常に簡単であることがわかります…これが、リフレクションを使用して静的ジェネリックメソッドを呼び出す方法です。

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