Gọi một phương thức tĩnh trên một tham số kiểu chung

Tôi đã hy vọng làm điều gì đó như thế này, nhưng nó có vẻ là bất hợp pháp trong C #:

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

Tôi gặp lỗi thời gian biên dịch: "'T' là 'tham số kiểu', không hợp lệ trong ngữ cảnh nhất định."

Với một tham số kiểu chung, làm cách nào để gọi một phương thức tĩnh trên lớp chung? Phương thức tĩnh phải có sẵn, với ràng buộc.

Trong trường hợp này, bạn chỉ nên gọi trực tiếp phương thức tĩnh trên kiểu bị ràng buộc. C # (và CLR) không hỗ trợ các phương thức tĩnh ảo. Vì thế:

T.StaticMethodOnSomeBaseClassThatReturnsCollection

... có thể không khác là:

SomeBaseClass.StaticMethodOnSomeBaseClassThatReturnsCollection

Đi qua tham số kiểu chung là một hướng không cần thiết và do đó không được hỗ trợ.

Để giải thích rõ hơn về câu trả lời trước, tôi nghĩ rằng sự phản ánh gần với những gì bạn muốn ở đây. Tôi có thể đưa ra 1001 lý do tại sao bạn nên hoặc không nên làm điều gì đó, tôi sẽ chỉ trả lời câu hỏi của bạn như đã hỏi. Tôi nghĩ bạn nên gọi phương thức GetMethod trên loại tham số chung và đi từ đó. Ví dụ, đối với một hàm:

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

Trong đó T là bất kỳ lớp nào có phương thức tĩnh fetchAll ().

Có, tôi biết rằng điều này rất chậm và có thể gặp sự cố nếu someParent không buộc tất cả các lớp con của nó thực hiện fetchAll nhưng nó trả lời câu hỏi như đã hỏi.

Cách duy nhất để gọi một phương thức như vậy là thông qua phản xạ, Tuy nhiên, có vẻ như có thể gói chức năng đó trong một giao diện và sử dụng mẫu IoC / factory / etc dựa trên phiên bản.

Có vẻ như bạn đang cố gắng sử dụng generic để giải quyết thực tế là không có "phương thức tĩnh ảo" nào trong C #.

Thật không may, điều đó sẽ không hoạt động.

Như bây giờ, bạn không thể. Bạn cần một cách để nói với trình biên dịch rằng T có phương pháp đó, và hiện tại, không có cách nào để làm điều đó. (Nhiều người đang thúc đẩy Microsoft mở rộng những gì có thể được chỉ định trong một ràng buộc chung, vì vậy có thể điều này sẽ khả thi trong tương lai).

Ở đây, tôi đăng một ví dụ hoạt động, đó là một giải pháp

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

Tôi chỉ muốn ném ra rằng đôi khi các đại biểu giải quyết những vấn đề này, tùy thuộc vào ngữ cảnh.

Nếu bạn cần gọi phương thức tĩnh dưới dạng một nhà máy hoặc phương thức khởi tạo nào đó, thì bạn có thể khai báo một ủy nhiệm và chuyển phương thức tĩnh cho nhà máy chung có liên quan hoặc bất kỳ phương thức nào cần "lớp chung với phương thức tĩnh này".

Ví dụ:

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

Thật không may, bạn không thể thực thi rằng lớp có phương thức phù hợp, nhưng ít nhất bạn có thể biên dịch-thời gian-thực thi rằng phương thức gốc kết quả có mọi thứ mà nó mong đợi (tức là một phương thức khởi tạo với chính xác chữ ký phù hợp). Điều này tốt hơn một ngoại lệ phản ánh thời gian chạy.

Cách tiếp cận này cũng có một số lợi ích, tức là bạn có thể sử dụng lại các phương thức init, đặt chúng là phương thức thể hiện, v.v.

Bạn có thể làm điều này bằng cách sử dụng phản chiếu, như được mô tả ở đây

Do liên kết đã chết, tôi tìm thấy các chi tiết liên quan trong máy quay lại:

Giả sử bạn có một lớp với một phương thức chung tĩnh:

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

Làm thế nào bạn có thể gọi phương pháp này bằng cách sử dụng chuyển hạng?

Hóa ra là rất dễ dàng… Đây là cách bạn gọi một phương pháp chung tĩnh bằng cách sử dụng 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" });