Вызов статического метода для параметра универсального типа

Я надеялся сделать что-то подобное, но в 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 / factory / etc на основе экземпляров.

Похоже, вы пытаетесь использовать дженерики, чтобы обойти тот факт, что в C # нет «виртуальных статических методов».

К сожалению, это не сработает.

На данный момент вы не можете. Вам нужен способ сообщить компилятору, что у T есть этот метод, и в настоящее время нет способа сделать это. (Многие подталкивают Microsoft к расширению того, что может быть указано в общем ограничении, поэтому, возможно, это станет возможным в будущем).

Здесь я публикую пример, который работает, это обходной путь

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

К сожалению, вы не можете обеспечить, чтобы у класса был правильный метод, но вы можете, по крайней мере, во время компиляции обеспечить, чтобы в результирующем заводском методе было все, что он ожидал (т.е. метод инициализации с точно правильной подписью). Это лучше, чем исключение отражения во время выполнения.

Этот подход также имеет некоторые преимущества, например, вы можете повторно использовать методы инициализации, сделать их методами экземпляра и т. Д.

Вы можете сделать это с помощью отражения, как описано здесь.

Из-за того, что ссылка не работает, я нашел соответствующие детали в машине обратного пути:

Предположим, у вас есть класс со статическим универсальным методом:

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

Как можно вызвать этот метод с помощью отражения?

Оказывается, это очень просто ... Вот как вы вызываете статический универсальный метод с помощью Reflection:

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