两个 C# 扩展泛型方法之间的不明确调用，一个 where T:class 和另一个 where T:struct

Question

考虑两种扩展方法：

public static T MyExtension<T>(this T o) where T:class
public static T MyExtension<T>(this T o) where T:struct

还有一个类：

class MyClass() { ... }

现在在上述类的实例上调用扩展方法：

var o = new MyClass(...);
o.MyExtension(); //compiler error here..
o.MyExtension<MyClass>(); //tried this as well - still compiler error..

当我在类上调用该方法时，编译器说调用该方法是一个模棱两可的调用。 我原以为它可以确定调用哪个扩展方法，因为 MyClass 是一个类，而不是一个结构？

Answer 1

编辑：我现在已经在博客上更详细地介绍了这一点。

---

我最初的（现在我认为是错误的）想法：在重载解析和类型推断阶段不考虑泛型约束 - 它们仅用于验证重载解析的结果。

编辑：好的，经过大量的讨论，我想我在那里。 基本上我的第一个想法几乎是正确的。

泛型类型约束仅用于在非常有限的情况下从候选集中删除方法……特别是，仅当参数本身的类型是泛型时； 不仅仅是一个类型参数，而是一个使用泛型类型参数的泛型类型。 此时，验证的是泛型类型的类型参数的约束，而不是您调用的泛型方法的类型参数的约束。

例如：

// Constraint won't be considered when building the candidate set
void Foo<T>(T value) where T : struct

// The constraint *we express* won't be considered when building the candidate
// set, but then constraint on Nullable<T> will
void Foo<T>(Nullable<T> value) where T : struct

因此，如果您尝试调用Foo<object>(null)则上述方法将不会成为候选集的一部分，因为Nullable<object> value无法满足Nullable<T>的约束。 如果有任何其他适用的方法，调用仍然可以成功。

现在在上面的情况下，约束完全相同......但它们不必如此。 例如，考虑：

class Factory<TItem> where TItem : new()

void Foo<T>(Factory<T> factory) where T : struct

如果您尝试调用Foo<object>(null) ，该方法仍将是候选集的一部分 - 因为当TItem是object ， Factory<TItem>表达的约束仍然有效，这就是构建候选时检查的内容放。 如果这被证明是最好的方法，那么它将在 7.6.5.1 接近尾声之后验证失败：

如果最佳方法是泛型方法，则根据泛型方法上声明的约束（第 4.4.4 节）检查类型参数（提供或推断）。 如果任何类型参数不满足类型参数的相应约束，则会发生绑定时错误。

Eric 的博客文章包含有关此的更多详细信息。

Answer 2

埃里克·利珀特 (Eric Lippert) 的解释比我以往任何时候都好， 在这里。

我自己也遇到过这种情况。 我的解决方案是

public void DoSomthing<T> (T theThing){
    if (typeof (T).IsValueType)
        DoSomthingWithStruct (theThing);
    else
        DoSomthingWithClass (theThing);  
}

// edit - seems I just lived with boxing

public void DoSomthingWithStruct (object theThing)
public void DoSomthingWithClass(object theThing)

Answer 3

我发现使用默认参数值在 .NET 4.5 中使用这种“有趣”的奇怪方法:) 也许对于教育\\推测目的比实际使用更有用，但我想展示它：

/// <summary>Special magic class that can be used to differentiate generic extension methods.</summary>
public class MagicValueType<TBase>
    where TBase : struct
{
}

/// <summary>Special magic class that can be used to differentiate generic extension methods.</summary>
public class MagicRefType<TBase>
    where TBase : class
{
}

struct MyClass1
{
}

class MyClass2
{
}

// Extensions
public static class Extensions
{
    // Rainbows and pink unicorns happens here.
    public static T Test<T>(this T t, MagicRefType<T> x = null)
        where T : class
    {
        Console.Write("1:" + t.ToString() + " ");
        return t;
    }

    // More magic, other pink unicorns and rainbows.
    public static T Test<T>(this T t, MagicValueType<T> x = null)
        where T : struct
    {
        Console.Write("2:" + t.ToString() + " ");
        return t;
    }
}

class Program
{
    static void Main(string[] args)
    {

        MyClass1 t1 = new MyClass1();
        MyClass2 t2 = new MyClass2();

        MyClass1 t1result = t1.Test();
        Console.WriteLine(t1result.ToString());

        MyClass2 t2result = t2.Test();
        Console.WriteLine(t2result.ToString());

        Console.ReadLine();
    }
}