C# 我应该如何在类层次结构中链接构造函数？

我们有以下类层次结构：

public class Base
{
    public Base()
    {
        // do generic initialization 
    }

    public Base(SomeClass param1) : this()
    {
        // init properties that require param1
    }

    public Base(SomeClass param1, OtherClass param2) : this(param1)
    {
        // init properties that require param2
    }

    // ...
}

public class Derived : Base
{
    public Derived()
    {
        // do custom initialization 
    }

    public Derived(SomeClass param1) : this() // ???
    {
        // do custom initialization using param1
    }

    public Derived(SomeClass param1, OtherClass param2) : this(param1) // ???
    {
        // do custom initialization using param2
    }

    // ...
}

---

我们需要

Derived

来运行它自己的初始化例程（链上）和基类中相应的例程。我们如何在不重复代码/运行某些构造函数两次的情况下链接构造函数？

您通常会将最少的构造函数链接到最多的构造函数，如下所示：

public Derived(SomeClass param1) : this(param1, param2)
{}

public class Base 
{
  public Base() : this(null, null)
  {
  }
  public Base(SomeClass param1) : this(param1, null)
  {
  }
  public Base(SomeClass param1, OtherClass param2)
  {
    if (param1 != null)
    {
      // initialise param1
    }
    if (param2 != null)
    {
      // initialise param2
    }
  }
}

public class Derived : Base
{
  public Derived() : this(null, null)
  {
  }
  public Derived(SomeClass param1) : this(param1, null)
  {
  }
  public Derived(SomeClass param1, OtherClass param2) : base(param1, param2)
  {
  }
} 

有关更多信息，请参阅上的这篇文章

编辑：

根据以下@Scott：

参数最多的是

公共派生的（SomeClass param1，OtherClass param2）：base（param1，param2）

，您将初始化代码放入

派生的
和
基的2参数构造函数中

为了证明调用了所有构造函数，我起草了一个程序：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    public class Base
    {
        public Base()
            : this(null, null)
        {
        }
        public Base(string param1)
            : this(param1, null)
        {
        }
        public Base(string param1, string param2)
        {
            Console.WriteLine("Base Class: " + param1 + "+" + param2);

            if (param1 != null)
            {
                // initialise param1
            }
            if (param2 != null)
            {
                // initialise param2
            }
        }
    }

    public class Derived : Base
    {
        public Derived()
            : this("", "")
        {
        }
        public Derived(string param1)
            : this(param1, "")
        {
        }
        public Derived(string param1, string param2)
            : base(param1, param2)
        {
            Console.WriteLine("Derived Class: " + param1 + "+" + param2);
        }
    } 
    class Program
    {
        static void Main(string[] args)
        {
            Derived d = new Derived("test1", "test2");
            Console.ReadLine();
        }
    }
}

输出：

Base class: test1+test2
Derived class: test1+test2

在派生类中，将参数最少的构造函数链接到参数最多的构造函数，然后将参数最多的派生构造函数链接到基。大概是这样的：

public Derived(SomeClass param1) : this(param1, param2)
{}

public class Base 
{
  public Base() : this(null, null)
  {
  }
  public Base(SomeClass param1) : this(param1, null)
  {
  }
  public Base(SomeClass param1, OtherClass param2)
  {
    if (param1 != null)
    {
      // initialise param1
    }
    if (param2 != null)
    {
      // initialise param2
    }
  }
}

public class Derived : Base
{
  public Derived() : this(null, null)
  {
  }
  public Derived(SomeClass param1) : this(param1, null)
  {
  }
  public Derived(SomeClass param1, OtherClass param2) : base(param1, param2)
  {
  }
} 

根据上下文的不同，最好使用default（T）而不是null来表示缺少的/默认值。
这将无法编译。param2来自哪里？此外，您似乎忽略了基本问题。如果他们调用它，您会将其设置为您想要的默认值。例如，如果两个字符串都
public派生（string param1）：this（param1，“”）
param2是一个文本、常量、静态字段或其他可用值。正如code Monkey所说，在派生类链中，参数最少的构造函数与参数最多的构造函数连接，然后，参数最多的派生构造函数被链接到base。@siride:要添加到@Code Monkey的注释中，参数最多的构造函数将是public-derived（SomeClass-param1，OtherClass-param2）：base（param1，param2）
然后将初始化代码放入派生和基中的2参数构造函数中。@Mihai:要用字符串演示，请参阅我的答案。它证明了所有构造函数都被调用。