c# - C# 规范是否禁止基于默认参数的类型推断？

Question

在下面的代码中，我试图在工厂模式中完成默认类型推导。我想使用参数的任意组合调用工厂方法，并从省略参数的默认参数中推断出泛型类型参数。但是，这种尝试会导致错误 CS1750。 CS1750 is mentioned in a handful of places in the roslyn repo ，但审查这些并没有透露太多关于这种情况的原因。

错误全文如下:

(parameter) S a = new S()

A value of type 'S' cannot be used as a default parameter because there are no standard conversions to type 'S' [TypeInference]csharp(CS1750)

public class T {}
public class T0  : T {}
public class T1  : T {}
// T2{} .. T9{}
public class T10 : T {}
public struct S<T> {}
public class X {} // X is a complex object strongly-typed with T1..T10
public static class C {
    public static X Factory<A,B/*,C..J*/>(
        S<T0> s = new S<T0>(), // this is fine
        S<A>  a = new S<T0>(), // ERROR: no standard conversions to type...
        S<B>  b = new S<T0>()  // ...'S<A>' [TypeInference]csharp(CS1750)
        //S<C> c,
        //...
        //S<J> j
    )
    where A : T
    where B : T
    =>throw new System.NotImplementedException();

    static void usage1() {
        /* I'd like to be able to omit an arbitrary portion
           of the factory arguments and have type inference use
           the default values.*/
        Factory(b : new S<T1>());
    }

    // simplified example
    public static void Foo<A>(A a)    {}
    public static void Bar<A>(A a=42) {} // ERROR: CS1750

    static void usage2() {
        Foo(42); // this is fine
    }
}

我一直在努力理解为什么CS1750被提出。根据the 5th edition of the spec

15.6.2 Method Parameters...

The expression in a default-argument shall be one of the following:...

• an expression of the form new S() where S is a value type

new S<T0>()似乎符合这个标准。确实，参数声明S<T0> s = new S<T0>()似乎没有引发错误。

阅读(诚然没有完全吸收)规范的类型推断部分，并不清楚为什么在类型推断期间不考虑默认值。该部分中的语言甚至似乎很小心地区分带有和不带有相应参数的可选参数。例如，在这句话中，缺少的可选参数被排除在推理失败的原因之外:

12.6.3 Type Inference...

If ... there is a non-optional parameter with no corresponding argument, then inference immediately fails.

与其排除默认参数，这似乎更像是一个弱建议，类型推断可以基于它们。

1. 为什么编译器试图转换 S<T0>至 S<A>而不是推断 A成为T0 ？
2. 规范是否禁止基于默认参数的类型推断？

Answer 1

我认为，您的问题 1 的答案是“编译器不是那样工作的”。正如我在评论中所做的那样，编译器期望程序员根据当前类型约束为默认参数提供有效类型。编译器不会根据默认参数的类型为您推断出泛型参数。这里唯一的限制是 A 和 T0 都是 T 的后代，所以通常我们不能期望 S<A> a = new S<T0>()上类。我很确定这就是错误的含义。

我认为，您的问题 2 真的是“它能那样工作吗？”。我认为理论上可以，但是存在一些问题。考虑一下如果在您的示例中有人调用电话 C.Factory<T1, T1>() 会发生什么，因此在不提供任何参数的情况下显式地将 A 设置为 T1 类型。现在我们在尝试分配 new S<T0>() 时遇到错误情况到我们的参数 a S<A> = S<T1> , 自 S<T0>不可分配给 S<T1> .编译器应该如何处理？由于 A 仅被限制为 T 的后代，并且 Factory 有一个不带参数的重载，因此调用看起来是有效的。因此，任何异常充其量都是令人困惑的，而且可能是错误的。但是我们不想在程序员明确要求不同的类型后将 A 推断为 T0。