Question

我有一个包含5个构造函数的类A：

来自IEnumerable<A>（例如A(new A[] {A1, A2})）
来自A[]使用params（前一个快捷方式，例如A(A1, A2)）
来自Vector<Complex>

IEnumerable<Complex>

（将可枚举转换为向量并调用前一个，例如A(new Complex[] {Complex1, Complex2})）
来自Complex[]使用params（前一个快捷方式，例如A(Complex1, Complex2)）

使用3个更具体的构造函数扩展B的类A：

来自Complex a, Complex b
来自double a, double b, double c, double d
来自double a, double b

以下代码：

public class A
{
    public A(params A[] array) : this((IEnumerable<A>)array) { }

    public A(IEnumerable<A> enumerable)
    {
        //
    }

    public A(params Complex[] array) : this((IEnumerable<Complex>)array) { } // Breaks shit

    public A(IEnumerable<Complex> enumerable) : this(Vector<Complex>.Build.DenseOfEnumerable(enumerable)) { }

    public A(Vector<Complex> vector)
    {
        //
    }
}

public class B : A
{
    public B(Complex a, Complex b)
    {
        //
    }

    public B(double a, double b, double c, double d)
    {
        //
    }

    public B(double a, double b)
    {
        //
    }
}

将Complex[]的构造函数添加到A后，A的所有三个构造函数都会出现以下错误：

Error CS0121 The call is ambiguous between the following methods or properties: 'A.A(params A[])' and 'A.A(params Complex[])'

我认为构造函数不是继承的，父类中的新构造函数如何干扰子类中的构造函数？如何解决这个问题？

我正在使用的模式允许各种等效类型的输入（例如A(Complex1, Complex2)，A(ComplexArray)和A(ComplexVector)）良好做法，或者我应该这样做不同？

Answer 1

构造函数按顺序从基类开始按顺序运行到最后继承的类。

public B(Complex a, Complex b)
{
    //
}

等于

public B(Complex a, Complex b) : base()
{
    //
}

编译器正在尝试查找基本类型（A）的构造函数，它不能接受任何参数。由于params关键字，有两个候选人：

public A(params A[] array) : this((IEnumerable<A>)array) { }

和

public A(params Complex[] array)  { }

您收到错误，因为编译器无法决定应该使用哪一个。要解决此问题，您可以重写B类的构造函数以使用基类构造函数：

public B(Complex a, Complex b) : base(a, b)
{
    //
}

Answer 2

我希望我能正确理解你的问题。

您不能覆盖基类的构造函数。如果var Foo = (function () { function Foo() { this.Bar = function Bar() { }; } return Foo; }());继承自B，并且如果两个类都具有相同签名的构造函数，则它将无效。始终执行基类的构造函数，但如果仍需要实现两个构造函数，则可以使用base关键字。

在你的情况下应该是：

两个构造函数仍然执行但现在你可以在public class B : A { public B(Complex a, Complex b) : base(a, b) { // Do some code here } public B(double a, double b, double c, double d) { // } public B(double a, double b) { // } }类的构造函数中编写逻辑。

＆＃34;以下方法或属性之间的呼叫不明确＆＃34;在儿童班上

2 个答案: