两个 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

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

class Factory<TItem> where TItem : new()

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

如果您尝试调用 Foo

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

Eric 的博客文章< /a> 包含更多详细信息。

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();
    }
}