当存在显式引用类型时，C# 可以推断 Object 构造上的通用参数吗？

Question

Java can infer generic type parameters when the reference type is explicitly given. For example, both of these are fine:

Set<String> set = new HashSet<string>();
Set<String> set2 = new HashSet<>();

Unfortunately if I try to do something similar in C# it doesn't seem supported:

//Doesn't compile
ISet<string> set = new HashSet<>();
//Works OK
ISet<string> set2 = new HashSet<string>();

I get two compiler messages in C# from the above:

CS7003 Unexpected use of an unbound generic name

and

CS0266 Cannot implicitly convert type 'System.Collections.Generic.HashSet' to 'System.Collections.Generic.ISet'. An explicit conversion exists (are you missing a cast?)

Is this feature genuinely not supported or am I just missing out on some C# syntax?

Answer 1

Thanks to a comment by canton7 we have an answer. The feature is not supported (yet) by C# but there are discussions around this in the pipelines. There are two possible directions this may be taken:

The Diamond Operator <>

There is the proposal to use the diamond operator, exactly as stated in the question:

https://github.com/dotnet/csharplang/issues/2935

This would allow one to use Java-like syntax as above, where the reference type is an interface and the object type is some implementation of that interface.

The new Keyword

There is the proposal to use the new keyword:

https://github.com/dotnet/csharplang/issues/100

This proposal, for example, would allow the following:

Point p = new Point(1, 2);

To be replaced with simply:

Point p = new (1, 2);

Indeed, for generic types, both the type, and any generics that come with it, would be inferred. So we could do, for example:

Hashset<string> set = new();

This initially seems more powerful than the diamond operator proposal. However, returning to the original example from the question, this feature, if developed, would not work for the case where the reference type is an interface. In that case, it would be unclear which object to create from new . For example if we did:

ISet<string> set = new ();

Then how would the compiler know which implementation of the ISet interface to use to instantiate an object of that type? So even if this feature were implemented, it wouldn't solve the use case where the reference type is an interface.