.NET中的链接构造函数

Question

我尝试通过尽可能多地重用构造函数来节省代码并降低可维护性的失败率。 现在，我遇到了一种情况，我认为我必须重复代码，但也许您知道一个解决方案。

public class Bar {
  public List<string> BarList {
    get;
    private set;
  }

  public Bar() {
    this.BarList = new List<string>();
  }

  public Bar(XmlNode node)
    : this() {
    //create from xml
  }
}

public class Foo: Bar {
  public List<int> FooList {
    get;
    private set;
  }
  public Foo()
    : base() {
    this.FooList = new List<int>();
  }

  public Foo(XmlNode node)
    : base(node) {
    //create from enhanced xml
  }
}

每个以XMLNode为参数的构造函数都在初始化之前调用无参数构造函数。 但是，如何管理派生类Foo调用其自己的无参数构造函数以及具有基类XmlNode参数的构造函数呢？

构造函数链的理想行为是：

Foo(XmlNode)->Bar(XmlNode)->Foo()->Bar()

Answer 1

为什么不抽象构造函数的工作？ 类似于：[检查新功能init]

public class Foo : Bar
{
    public List<int> FooList
    {
        get;
        private set;
    }
    public Foo()
      : base()
    {
        Init();
    }

    private void Init() { this.FooList = new List<int>(); }

    public Foo(XmlNode node)
      : base(node)
    {
        Init();
        //create from enhanced xml
    }
}

Answer 2

如果我正确理解了您的问题，则希望Foo(XmlNode node)调用this()和base(node) ，这是无法完成的。

btw： ctor() : base()或在您的情况下Foo() : base()是隐式的。

您唯一的选择是有点代码冗余。

例如：

public class Foo: Bar {
    public List<int> FooList { get; private set; }

    public Foo() : base() {
        Initialize();
    }

    public Foo(XmlNode node) : base(node) {
        Initialize();
    }

    protected void Initialize() {
        this.FooList = new List<int>();
    }
}

Answer 3

正如其他人回答的那样，除非将行为抽象到单独的方法中，否则您将无法做的事情。

但是，如果您要坚持使用构造函数，则可以选择使用可选参数，如下所示：

public class Bar {
  public List<string> BarList {
    get;
    private set;
  }

  public Bar(string xmlNode = null) {
    this.BarList = new List<string>();

    if (xmlNode != null) { 
        //create from xml 
    }
  }
}

public class Foo: Bar {
  public List<int> FooList {
    get;
    private set;
  }
  public Foo(string xmlNode = null)
  : base(xmlNode)
  {
    this.FooList = new List<int>();

    if (xmlNode != null) { 
        //create from enhanced xml 
    }
  }
}

当然，这里的折衷之处在于现在构造函数中具有分支逻辑。

Answer 4

这就是为什么我总是以相反的方式链接构造函数的原因（无参数调用带有一个参数的ctor，而调用带有两个参数的ctor，等等）。 每个构造函数的目的只是为缺少的参数提供默认值，并且其主体保持为空。 然后，所有工作将在最专门的构造函数中完成，该构造函数调用基类的最专门的构造函数。 这样，您始终只需要维护一个实现。

public abstract class Bar
{
    public List<string> BarList { get; private set; }

    public Bar()
        : this(null)
    { }

    public Bar(XmlNode node)
    {
        this.BarList = new List<string>();

        if (node == null)
            return;

        //create from xml
    }
}

public class Foo : Bar
{
    public List<int> FooList { get; private set; }

    public Foo()
        : this(null)
    { }

    public Foo(XmlNode node)
        : base(node)
    {
        this.FooList = new List<int>();

        if (node == null)
            return;

        //create from enhanced xml
    }
}