C#泛型类型引起歧义

Question

我正在创建一个自定义泛型类：

class Widget< T1, T2>
{
    ...
    public bool Bar( T1 type1 )
    {
        ...
    }
    public bool Bar( T2 type2 )
    {
        ...
    }
    ...
}

以下代码会产生一个含糊不清的调用编译错误：

Widget<int, int> Foo = new Widget<int, int>();
...
Foo.Bar(5);
...

有没有办法解决这个问题？是否可以添加一个类似于“where：TypeOf（T1）！= TypeOf（T2）”的条款，或者任何使其不明确的方法？最好是int，int可用，但不强制要求。

更新：

实际上我自己发现了一个对我来说可接受的解决方案，对于那些感兴趣的人。

class Widget< T1, T2>
{
    ...
    public bool Bar( object o )
    {
        if( o.GetType() == typeof(T1) )
        {
            ...
        }
        if( o.GetType() == typeof(T2) )
        {
            ...
        }
    }
    ...
}

- Steve H.

---

我想知道这个在现实世界中的应用场景是什么... - user76035

实际上它变成了无效的方法重载。 - Perpetualcoder

@wwosik：一个有两个键的字典。 - Steve H.

Answer 1

有没有一种类似于"where：TypeOf（T1）！= TypeOf（T2）"的条款？

您可以使构造函数在运行时引发异常。但是，在编译时无法防止这种情况。

有什么办法可以使这个问题不含糊吗？

您应该更改方法的名称，以便它们不会发生冲突。这是迄今为止最安全和最简单的方法。

实际上，如果CLR保留在方法签名中产生歧义的类型创建类型失败的权利。（显然，我们的实现实际上确实成功了，但是当您进行这些恶作剧时，您会走在非常薄冰上。）

这样做是一个非常糟糕的想法，因为它可能会让您遇到各种麻烦。以下是事情出错的示例：

http://blogs.msdn.com/ericlippert/archive/2006/04/05/odious-ambiguous-overloads-part-one.aspx

http://blogs.msdn.com/ericlippert/archive/2006/04/06/odious-ambiguous-overloads-part-two.aspx

还要注意，编译器会阻止您创建一种类型，使其实现了两个在构造下可能相同的接口。这是非法的：

class C<T, U> : IFoo<T>, IFoo<U> { ... }

因为你可以构造C<int, int>，而CLR无法知道哪些方法对应哪些接口槽位。

但是我似乎有点跑题了。回到主题。

既然你是这个类的创建者，你可以选择重命名你的"Bar"方法，使它们在任何可能的构造下都是不同的。假设你固执地选择不这样做。如果用户想要创建Widget<int, int>，他们能做些什么呢？实际上是可以的，正如kvb指出的那样。他们可以定义正确操作的扩展方法。

public static void BarTheFirst<A, B>(this Widget<A, B> w, A a)
{
    w.Bar(a);
}

public static void BarTheFirst<A, B>(this Widget<A, B> w, B b)
{
    w.Bar(b);
}

重载决议是在编译时完成的，而在编译时我们只知道第一个调用了接受"A"的Bar函数，而第二个调用了接受"B"的Bar函数。我们不会在运行时重新执行重载决议，因此现在可以这样说：

Widget<int, int> w = whatever;
w.BarTheFirst(5);
w.BarTheSecond(10);

它会做正确的事情。

- Eric Lippert

---

事实上，如果CLR在方法签名中出现歧义的类型无法创建，我记得CLR保留这种权利。真的吗？如果是这样，当您创建Widget<int,int>时，C#编译器不应该至少发出警告吗？ - Mehrdad Afshari

@wwosik：那个错误是针对方法调用的。Eric谈到的是CLR在创建这种类型时炸掉程序。实际上，当我想起来的时候，编译器很难弄清楚它在深度嵌套的泛型方法中，比如外部程序集中。 - Mehrdad Afshari

在语言设计的某个阶段，设计使得创建任何可能构造出任何签名冲突的通用类型都是非法的。这意味着类C<T> { static C<T> Factory(T t) {...} static C<T> Factory(SerializedState s) {...} }将是非法的，因为T可以是SerializedState！尽管我们早期就放弃了这种设计，但在该过程中晚了一些，以至于C# 2.0绑定规范实际上是这样说的。我同意在这些情况下产生警告会很好，但实际上它们并不经常出现。 - Eric Lippert

Answer 2

给你的函数取一个独特的名字

- Kerido

---

构造函数怎么办，不能改名字。显然，他知道可以使用不同的名称，所以你的回答是无意义的，抱歉。 - Bojidar Stanchev

Answer 3

我同意其他人的观点，你应该更改你的类，以避免发生冲突（例如通过重命名方法）。然而，如果你不拥有这个类，还是有一个解决方法的：

public static class WidgetExtensions
{
    public static bool Bar1<T1,T2>(this Widget<T1, T2> w, T1 t1) { return w.Bar(t1); }
    public static bool Bar2<T1,T2>(this Widget<T1, T2> w, T2 t2) { return w.Bar(t2); }
}

您可以使用这些扩展方法来调用正确的 Bar 重载。静态方法不需要是扩展方法，但我认为这会使它更清晰明了。

- kvb

Answer 4

这似乎是一个需要基础泛型类的情况

abstract class WidgetBase<T1>
{

    public abstract bool Bar(T1 type);
    ... 
}

然后继承你的实现

class WidgetA : WidgetBase<int>
{
     public bool Bar(int type)
     {
         ...
     }
}

class WidgetB : WidgetBase<int>
{
     public bool Bar(int type)
     {
         ...
     }
}

- Nate Heinrich