C# 一个构造函数调用另一个构造函数

如果有多个构造函数，那么由另一个构造函数调用一个构造函数有什么好处？

---

谢谢你不要重复了

实现一个构造函数的更改也会立即影响所有其他构造函数。

---

复制和粘贴代码是不好的，应该避免。

方法重载的相同优点是：不重复相同的代码

public class Person
{
    public Person(string name,string lastName )
    {
        Name = name;
        LastName = lastName;
    }

    public Person(string name, string lastName,string address):this(name,lastName)
    {
        //you don't need to set again Name and Last Name
        //as you can call the other constructor that does the job
        Address = Address;
    }
    public string Name { get; set; }
    public string LastName { get; set; }
    public string Address { get; set; }
}

---

如果要将默认值传递给基构造函数

public class YourClass
{
    private int SomeInt;

    public YourClass() : this(0)
    {
        // other possible logic
    }

    public YourClass(int SomeNumber)
    {
        SomeInt = SomeNumber;
    }
}

---

这遵循干燥原则（不要重复）。这是一个简单的例子，但应该能说明这一点。

当我想将默认值或空值传递给其他构造函数时，我使用了它。在上面的例子中，用户在调用构造函数时不必传递null——他们可以不带任何内容地调用它

public class Widget(){

    public Widget() : this(null){

    }

    public Widget(IRepository rep){
      this.repository = rep;
    }
}

---

看看已经发布的答案，我会告诉他们你总是从默认的构造函数走到最专业的构造函数。尝试以另一种方式执行同样的操作总是会导致代码重复或出现问题：

好方法：

public class Foo()
{
    public Foo()
      : this(String.Empty)
    { }

    public Foo(string lastName)
      : this(lastName, String.Empty)
    { }

    public Foo(string lastName, string firstName)
      : this(lastName, firstName, 0)
    { }

    public Foo(string lastName, string firstName, int age)
    {
        LastName = lastName;
        FirstName = firstName;
        Age = age;
        _SomeInternalState = new InternalState();
    }
}

public class Foo()
{
    public Foo(string lastName, string firstName, int age)
      : this(lastName, firstName)
    {
        Age = age;
    }

    public Foo(string lastName, string firstName)
      : this(lastName)
    {
        FirstName = firstName;
    }

    public Foo(string lastName)
      : this()
    {
        LastName = lastName;
    }

    public Foo()
    {
        _SomeInternalState = new InternalState();
    }
}

坏方法：

public class Foo()
{
    public Foo()
      : this(String.Empty)
    { }

    public Foo(string lastName)
      : this(lastName, String.Empty)
    { }

    public Foo(string lastName, string firstName)
      : this(lastName, firstName, 0)
    { }

    public Foo(string lastName, string firstName, int age)
    {
        LastName = lastName;
        FirstName = firstName;
        Age = age;
        _SomeInternalState = new InternalState();
    }
}

public class Foo()
{
    public Foo(string lastName, string firstName, int age)
      : this(lastName, firstName)
    {
        Age = age;
    }

    public Foo(string lastName, string firstName)
      : this(lastName)
    {
        FirstName = firstName;
    }

    public Foo(string lastName)
      : this()
    {
        LastName = lastName;
    }

    public Foo()
    {
        _SomeInternalState = new InternalState();
    }
}

---

第二个示例的问题是，处理所有参数的部分现在在所有构造函数中都很混乱，而不是在一个（最专业的）构造函数中实现。想象一下，您喜欢从这个类派生。在第二个示例中，必须重写所有构造函数。在第一个示例中，您只需重写最专业的构造函数即可完全控制每个构造函数。

Related:那么，从一个方法调用另一个方法有什么好处？构造函数只是在生成

new

操作符的结果之前调用的方法。我不喜欢这个例子。您可能应该以另一种方式级联。从最高的论点到lowest@Kyle：nnnooooo。按照你的建议去做会导致问题。查看我的更新答案。我不确定我是否理解了要点…如果

Foo

是一个父类，并且您有class

Bar:Foo

，并且您想要实现

Bar（last，first）：base（last，first）

我认为这两种方法都没有问题。我会说，第一种方法可以很好地将所有参数设置在一个地方，只是为了寻找，但它并不涵盖所有可能需要链接构造函数的情况。设想两个构造函数在安装过程中调用不同的方法，它们有一个共同的“基本”实现，但不应该互相调用

public class YourClass
{
    private int SomeInt;

    public YourClass() : this(0)
    {
        // other possible logic
    }

    public YourClass(int SomeNumber)
    {
        SomeInt = SomeNumber;
    }
}