没有为泛型类中的静态方法设置类型

Question

Not a fan of Java, but Java allows not setting types for generic classes and in that case it threats the type as Object type. However, as far as I know, C# enforces setting the type of <T> anytime the generic class has to be instantiated or simply speaking used. However, let's say that we have a generic class, and we need a static method in there which does not rely on the type of <T> .

Firstly, we know that it can be moved to a separate context or we can set a dummy type of <T> , but as a programming puzzle is there any way to call it Without defining the type of T ?

Example:

 class Test<T> where T: ITestable {
     ...
     public static void CreateTestFile(String fileName) {...}
 }
 Test.CreateTestFile("test.txt");

This can be done Java and apparently can't be in C#. But I just wanna make sure.

Answer 1

Java and C# implement generics differently:

• Java uses type erasure , which basically means that at compile time, anything you put in <T> is erased and becomes Object . Something<Foo> and Something<Bar> will be the same type at runtime, and wil be effectively equal to Something<Object> .

• C# uses run-time reification , meaning that for each type you use with a distinct T , the runtime generates a new class altogether, by using the open generic version as a template (which means it also generates the underlying native code once per T as you call it). Something<Foo> and Something<Bar> are two unrelated types as far as the CLR is concerned.

Hopefully you understand why this difference is important to your scenario. Ignoring T is trivial in Java, but not so easy in C#.

If you don't need T in your code, then use a non-generic method:

abstract class Test
{
    public static void CreateTestFile(String fileName) {...}
}

class Test<T> : Test
    where T : ITestable
{
     ...
}

Here, that's better :)

Also, note that for instance methods, you can use covariant and contravariant interfaces to loosen the requirement for a known T at compile-time. For instance, if you use a covariant interface, you only need to know a base type of T .

Answer 2

You should really consider separating your concerns, placing that public static method elsewhere. However, if you really want to call it, this would work just fine:

class Program
{
    static void Main(string[] args)
    {
        Test<ITestable>.CreateTestFile("test.txt");
    }
}

class Test<T> where T : ITestable
{
     public static void CreateTestFile(String fileName) { }
}

public interface ITestable { }

If you had a constraint where T : class, new() , you could do something similar:

class Program
{
    static void Main(string[] args)
    {
        Test<object>.CreateTestFile("test.txt");
    }
}

class Test<T> where T : class, new()
{
     public static void CreateTestFile(String fileName) { }
}

public interface ITestable { }

If you had an even weirder constraint like where T : class, ITestable, new() I'd stop worrying about getting the compiler to jump through your hoops, rethink your design, and separate the concerns along these lines:

class Program
{
    static void Main(string[] args)
    {
        Util.CreateTestFile("test.txt");
    }
}

class Util
{
    public static void CreateTestFile(String fileName) { }
}

class Test<T> where T : class, ITestable, new()
{
    /*...*/
}

public interface ITestable { }