Question

给出

class Either<A, B> {

    public Either(A x) {}
    public Either(B x) {}
}

当两个类型参数相同时，如何消除两个构造函数之间的歧义？

例如，这一行：

var e = new Either<string, string>("");

失败：

以下方法或属性之间的调用不明确：'Program.Either.Either（A）'和'Program.Either.Either（B）'

我知道如果我给出了不同名称的参数（例如A a和B b而不仅仅是x），我可以使用命名参数来消除歧义（例如new Either<string, string>(a: "") ）。但我很想知道如何在不改变Either的定义的情况下解决这个问题。

编辑：

你可以编写几个智能构造函数，但我很想知道Either的构造函数是否可以直接调用而不会产生歧义。（或者除了这个之外还有其他“技巧”）。

static Either<A, B> Left<A, B>(A x) {
    return new Either<A, B>(x);
}

static Either<A, B> Right<A, B>(B x) {
    return new Either<A, B>(x);
}

var e1 = Left<string, string>("");
var e2 = Right<string, string>("");

Answer 1

当两个类型参数相同时，如何消除两个构造函数之间的歧义？

我首先回答你的问题，然后用一个实际的答案来完成，让你解决这个问题。

你没有必要，因为你不应该首先让自己进入这个位置。创建泛型类型是一种设计错误，可以使成员签名以这种方式统一。永远不要写那样的课。

如果你回过头来阅读最初的C＃2.0规范，你会发现原始设计是让编译器检测到以任何可能的方式的通用类型来解决这类问题出现，并使阶级宣言非法。这使它成为已发布的规范，尽管这是一个错误;设计团队意识到这个规则太严格了，因为有以下情况：

class C<T> 
{
  public C(T t) { ... }
  public C(Stream s) { ... deserialize from the stream ... }
}

说这个类是非法的是很奇怪的，因为你可能会说C<Stream>然后无法消除构造函数的歧义。相反，在重载决策中添加了一条规则，即如果在(Stream)和(T where Stream is substituted for T)之间进行选择，则前者获胜。

因此，这种统一是非法的规则被废弃，现在允许。然而，制作以这种方式统一的类型是一个非常非常糟糕的主意。在某些情况下，CLR处理得很差，而且编译器和开发人员都很困惑。例如，您是否想要猜测该程序的输出？

using System;
public interface I1<U> {
    void M(U i);
    void M(int i);
}

public interface I2<U> {
    void M(int i);
    void M(U i);
}

public class C3: I1<int>, I2<int> {
    void I1<int>.M(int i) {
        Console.WriteLine("c3 explicit I1 " + i);
    }
    void I2<int>.M(int i) {
        Console.WriteLine("c3 explicit I2 " + i);
    }
    public void M(int i) { 
        Console.WriteLine("c3 class " + i); 
    }
}

public class Test {
    public static void Main() {
        C3 c3 = new C3();
        I1<int> i1_c3 = c3;
        I2<int> i2_c3 = c3;
        i1_c3.M(101);
        i2_c3.M(102);
    }
}

如果你在打开警告的情况下编译它，你会看到我添加的警告，解释为什么这是一个非常非常糟糕的主意。

不，真的：当两个类型参数相同时，如何消除两个构造函数之间的歧义？

像这样：

static Either<A, B> First<A, B>(A a) => new Either<A, B>(a);
static Either<A, B> Second<A, B>(B b) => new Either<A, B>(b);
...
var ess1 = First<string, string>("hello");
var ess2 = Second<string, string>("goodbye");

这个类应该首先设计的方式。 Either类的作者应该写

class Either<A, B> 
{
  private Either(A a) { ... }
  private Either(B b) { ... }
  public static Either<A, B> First(A a) => new Either<A, B>(a);
  public static Either<A, B> Second(B b) => new Either<A, B>(b);
  ...
}
...
var ess = Either<string, string>.First("hello");

Answer 2

我能想到的唯一方法是使用反射来迭代每个构造函数，然后根据方法体确定应该使用哪个构造函数。

当然这是超越顶级的，你应该真正重构你的课程，但这是一个有效的解决方案。

它要求您确定要使用的方法体的byte[]和进入程序的“硬代码”（或从文件中读取等）。当然，您需要非常谨慎，方法体可能会随着时间的推移而发生变化，例如，如果在任何时候修改了类。

// You need to set (or get from somewhere) this byte[] to match the constructor method body you want to use.
byte[] expectedMethodBody = new byte[] { 0 };

Either<string, string> result = null; // Will hold the result if we get a match, otherwise null.
Type t = typeof(Either<string, string>); // Get the type information.

// Loop each constructor and compare the method body.
// If we find a match, then we invoke the constructor and break the loop.
foreach (var c in t.GetConstructors())
{
    var body = c.GetMethodBody();
    if (body.GetILAsByteArray().SequenceEqual(expectedMethodBody))
    {
        result = (Either<string, string>)c.Invoke(new object[] { "123" });
        break;
    }
}

免责声明：虽然我已经对此代码进行了简要测试，但它似乎有效，但我对它的可靠程度持怀疑态度。我不太了解编译器，即使代码没有改变，也很容易说方法体在重新编译时不会改变。如果在预编译的DLL中定义了这个类，它可能会变得更加可靠，但我不确定这一点。

可能是您可以通过反射获得的其他信息，可以更容易地识别正确的构造函数。然而，这是第一个想到的，我现在还没有真正研究过任何其他可能的选择。

如果我们可以依赖构造函数的顺序会更简单，但是as quoted from MSDN，它不可靠：

GetConstructors方法不按特定顺序返回构造函数，例如声明顺序。您的代码不能依赖于返回构造函数的顺序，因为该顺序会有所不同。

当两个类型参数相同时，消除两个构造函数之间的歧义

2 个答案: