52

如果编译器可以推断，C# 不需要您指定泛型类型参数，例如：

List<int> myInts = new List<int> {0,1,1,
    2,3,5,8,13,21,34,55,89,144,233,377,
    610,987,1597,2584,4181,6765};

//this statement is clunky
List<string> myStrings = myInts.
    Select<int,string>( i => i.ToString() ).
    ToList<string>();

//the type is inferred from the lambda expression
//the compiler knows that it's taking an int and 
//returning a string
List<string> myStrings = myInts.
    Select( i => i.ToString() ).
    ToList();

这对于您不知道类型参数是什么的匿名类型是必需的（在智能感知中，它显示为'a），因为它是由编译器添加的。

类级类型参数不允许您这样做：

//sample generic class
public class GenericDemo<T> 
{
    public GenericDemo ( T value ) 
    {
        GenericTypedProperty = value;
    }

    public T GenericTypedProperty {get; set;}
}

//why can't I do:
int anIntValue = 4181;
var item = new GenericDemo( anIntValue ); //type inference fails

//however I can create a wrapper like this:
public static GenericDemo<T> Create<T> ( T value )
{
    return new GenericDemo<T> ( value );
}

//then this works - type inference on the method compiles
var item = Create( anIntValue );

为什么 C# 不支持此类级别的泛型类型推断？

4

3 回答 3

31

其实你的问题还不错。过去几年我一直在玩弄一种通用编程语言，虽然我从来没有真正开发过它（可能永远不会），但我对泛型类型推断思考了很多，我的首要任务之一是一直以来都允许构造类而不必指定泛型类型。

C# 只是缺乏使这成为可能的一组规则。我认为开发人员从来没有看到有必要包括这个。实际上，以下代码将非常接近您的提议并解决问题。所有 C# 需要的是附加的语法支持。

class Foo<T> {
    public Foo(T x) { … }
}

// Notice: non-generic class overload. Possible in C#!
class Foo {
    public static Foo<T> ctor<T>(T x) { return new Foo<T>(x); }
}

var x = Foo.ctor(42);

由于这段代码确实有效，我们已经证明问题不在于语义，而只是缺乏支持。我想我必须收回我之前的帖子。;-)

于 2008-09-05T12:58:05.767 回答
10

为什么 C# 不支持此类级别的泛型类型推断？

因为它们通常是模棱两可的。相比之下，类型推断对于函数调用来说是微不足道的（如果所有类型都出现在参数中）。但是在构造函数调用的情况下（为了讨论而美化的函数），编译器必须同时解析多个级别。一个级别是类级别，另一个是构造函数参数级别。我相信解决这个问题在算法上并非易事。直觉上，我会说它甚至是 NP 完全的。

为了说明无法解析的极端情况，想象下面的类并告诉我编译器应该做什么：

class Foo<T> {
    public Foo<U>(U x) { }
}

var x = new Foo(1);
于 2008-09-05T12:05:24.643 回答
2

谢谢康拉德，这是一个很好的回应（+1），但只是为了扩展它。

让我们假设 C# 有一个显式的构造函数：

//your example
var x = new Foo( 1 );

//becomes
var x = Foo.ctor( 1 );

//your problem is valid because this would be
var x = Foo<T>.ctor<int>( 1 );
//and T can't be inferred

你说得对，第一个构造函数不能被推断出来。

现在让我们回到课堂

class Foo<T> 
{
    //<T> can't mean anything else in this context
    public Foo(T x) { }
}

//this would now throw an exception unless the
//typeparam matches the parameter
var x = Foo<int>.ctor( 1 );

//so why wouldn't this work?
var x = Foo.ctor( 1 );

当然，如果我重新添加您的构造函数（使用它的替代类型），我们会有一个模棱两可的调用 - 就像无法解决正常的方法重载一样。

于 2008-09-05T12:48:42.480 回答